集合源码学习(六):TreeMap

从这篇博客开始，慢慢一起学习Map集合

什么是Map？

Map和List不同，
在List中，我们记得主要是线性表，List中又可以细分为基于数组实现(ArrayList,Vector, ..)，基于链表实现(LinkedList, …)。并且主要是List只有value，即只有一个值。
而在Map中 ，存储的是一个键值对 组合，即key-value。基本操作都是作用于这个组合。
看Map接口的实现：

public interface Map<K,V>

而对于构造Map的方式又有多种，本文主要介绍TreeMap，基于红黑树 的Map实现方式。

TreeMap的基本特征

先看定义：

public class TreeMap<K,V>    extends AbstractMap<K,V>    implements NavigableMap<K,V>, Cloneable, java.io.Serializable

1）：有序性
NavigableMap是一个扩展SortedMap的集合，因而TreeMap也是有序的，注意这里的有序性和ArrayList里面的顺序性不同
好比10个小朋友站队，
在ArrayList里面，依次进入，我不能保证在里面是按照高矮排序的，但是一定是顺序的，也就是如果张三在李四前面进，
王五在李四后面进，那么最终队列中，李四前后就一定是张三和王五（当然方位关系，也可为王五和张三）。
而在TreeMap里面，由于结构不同，所以就不是线性表这样一条线，但是通过iterator遍历的时候(通过身高确定的comparator)，就能够保证最终按照身高高矮顺序输出。
所以二者不同。

2）：元素值空值问题
由上特点分析，TreeMap是有序的，而在里面其实是通过Comparator来比较的，这样才会有序嘛，并且在创建一个TreeMap的时候，可以传入Comparator辅助排序，或者用默认的Comparator进行判定大小(强行用父类compareTo进行比较的)。这样的意图是什么呢，也就是你可以将键设为空值（null），前提是你要自己传一个Comparator，考虑到null的情况。当然值也是能为null的，正常存正常输出。
先看获取值的源码：

 final Entry<K,V> getEntry(Object key) {        // Offload comparator-based version for sake of performance        if (comparator != null)            return getEntryUsingComparator(key);           //默认情况下，不允许key为null        if (key == null)            throw new NullPointerException();        @SuppressWarnings("unchecked")            Comparable<? super K> k = (Comparable<? super K>) key;        Entry<K,V> p = root;        while (p != null) {            int cmp = k.compareTo(p.key);            if (cmp < 0)                p = p.left;            else if (cmp > 0)                p = p.right;            else                return p;        }        return null;    }    //当用了自己的Comparator的时候      final Entry<K,V> getEntryUsingComparator(Object key) {        @SuppressWarnings("unchecked")            K k = (K) key;        Comparator<? super K> cpr = comparator;        if (cpr != null) {            Entry<K,V> p = root;            while (p != null) {                int cmp = cpr.compare(k, p.key);                if (cmp < 0)                    p = p.left;                else if (cmp > 0)                    p = p.right;                else                    return p;            }        }        return null;    }

3）：不允许重复
当插入一个新值的时候，会沿着二叉树一直向下找，知道找到合适位置，如果找到key相等的话，就会产生替换操作，所以是不允许重复的，具体原理在下文将put操作会分析。
但是也有一个特例，类似于上面分析可以加null作为键，TreeMap里面都是用comparator来实现比较的，所以当你传入的元素在comparable里面懂了手脚，比如相等也返回1的话，就可以加入重复值了。

4）：操作的时间复杂度
在jdk描述中，指出在get，put，remove等操作方法中，都具有log(n)的时间复杂度，即查找、插入和删除在平均和最坏情况下都是O（log n）。在下文具体分析中可知悉。

5）：非线程安全
TreeMap非线程安全，使用时注意同步或者使用包装类进行同步。

synchronizedSortedMap Collections.synchronizedSortedMap

TreeMap的原理

TreeMap是基于二叉树实现的，这里不了解二叉树的可以看看网上的一些文章，而在二叉树里面又分为多种类型的树，有一种树叫做AVL，这里可以了解下：AVL 。而在AVL树的具体实现中，又有一种典型的实现方法，这就是红黑树了红黑树 。
而在Java中TreeMap，就是基于这种红黑树实现的。
或许说道这里，还是有很多读者会很蒙，不太理解TreeMap是啥，下面介绍下红黑树的基本特征，最后会给出简单易懂的TreeMap原理。

红黑树

二叉查找树
由于红黑树本质上就是一棵二叉查找树，所以在了解红黑树之前，咱们先来看下二叉查找树。
二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

-若任意结点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；-若任意结点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；-任意结点的左、右子树也分别为二叉查找树。-没有键值相等的结点（no duplicate nodes）。

因为，一棵由n个结点，随机构造的二叉查找树的高度为lgn，所以顺理成章，一般操作的执行时间为O（lgn）。

但二叉树若退化成了一棵具有n个结点的线性链后，则此些操作最坏情况运行时间为O（n），也就是编程斜着的一根。后面我们会看到一种基于二叉查找树-红黑树，它通过一些性质使得树相对平衡，使得最终查找、插入、删除的时间复杂度最坏情况下依然为O（lgn）。

红黑树
而红黑树，也是一棵二叉树。
但它是如何保证一棵n个结点的红黑树的高度始终保持在h = logn的呢？这就引出了红黑树的5条性质：

1）每个结点要么是红的，要么是黑的。  2）根结点是黑的。  3）每个叶结点（叶结点即指树尾端NIL指针或NULL结点）是黑的。  4）如果一个结点是红的，那么它的俩个儿子都是黑的。  5）对于任一结点而言，其到叶结点树尾端NIL指针的每一条路径都包含相同数目的黑结点。

也正是这5条性质保证了这棵红黑树高度为log（n），所以保证了查找、插入、删除的时间复杂度最坏为O(log n)。
什么时候会用到这5条新值呢？就是当你对树的结构进行了改变(插入，删除)时，就需要调整来保证这5条性质所以改变
后还是一棵红黑树。
先看一张图了解下：（就是平衡二叉树，加上红黑颜色节点限制）

树的旋转知识
主要包括左旋和右旋，在平衡二叉树中，用于调整二叉树的最大高度差不超过1。
左旋：

右旋：

插入及调整
接下来就是红黑树的插入过程，
首先是要确定新加入的节点适合放到哪个位置，步骤就是从根节点向下遍历，左小右大。
当找到之后，就将值插入，但是插入过程后，树的结构和相关性质就会发生变化导致不再符合红黑树的特征，此时就需要调整
经过调整步骤后，树的结构就再一次符合了红黑树的特征了，并且值也插进去了。
这里就不再详细讲红黑树插入算法，本文主要集中篇幅将Java中TreeMap，当然理解了红黑树后，也就可以轻松理解TreeMap了，深入了解可访问
julycoding

删除及调整
和插入步骤一样，不细讲
先找到节点，再删除节点，调整。

总括
红黑树就是一棵平衡二叉树，它的红黑结构保证了它的树的平衡性，保证了插入、删除、查找的效率即log(n)，所以每当插入节点之后，再进行调整，以保证树的红黑结构。

TreeMap源码剖析

这里把TreeMap的具体动作方法进行介绍。

传入一个有序集合进行构造

   public TreeMap(SortedMap<K, ? extends V> m) {        comparator = m.comparator();        try {            //从有序集合里面建立一个treemap            buildFromSorted(m.size(), m.entrySet().iterator(), null, null);        } catch (java.io.IOException cannotHappen) {        } catch (ClassNotFoundException cannotHappen) {        }    }    /**     * 从有序集合中获得数据并插入。     * 注意是有序的     */    private void buildFromSorted(int size, Iterator<?> it,                                 java.io.ObjectInputStream str,                                 V defaultVal)        throws  java.io.IOException, ClassNotFoundException {        this.size = size;        root = buildFromSorted(0, 0, size-1, computeRedLevel(size),                               it, str, defaultVal);    }    /**     * 插入操作     *     * level ：当前节点应该插入的层     * lo：子树的第一个节点     * hi：子树的最后一个节点     * @param 表明该层该节点必须为红色     */    @SuppressWarnings("unchecked")    private final Entry<K,V> buildFromSorted(int level, int lo, int hi,                                             int redLevel,                                             Iterator<?> it,                                             java.io.ObjectInputStream str,                                             V defaultVal)        throws  java.io.IOException, ClassNotFoundException {        //判断是否有错误        if (hi < lo) return null;        int mid = (lo + hi) >>> 1;        Entry<K,V> left  = null;        //一直往下递归找到左子节点        if (lo < mid)            left = buildFromSorted(level+1, lo, mid - 1, redLevel,                                   it, str, defaultVal);        //找到了，设置值的过程。        K key;        V value;        if (it != null) {            if (defaultVal==null) {                Map.Entry<?,?> entry = (Map.Entry<?,?>)it.next();                key = (K)entry.getKey();                value = (V)entry.getValue();            } else {                key = (K)it.next();                value = defaultVal;            }        } else { // use stream            key = (K) str.readObject();            value = (defaultVal != null ? defaultVal : (V) str.readObject());        }        Entry<K,V> middle =  new Entry<>(key, value, null);        // 设置完之后，就开始设置color以及将节点和待插入位置的父子节点连接起来。        if (level == redLevel)            middle.color = RED;        if (left != null) {            middle.left = left;            left.parent = middle;        }        if (mid < hi) {            //递归的方式，去获得下一个右下字节点            Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel,                                               it, str, defaultVal);            middle.right = right;            right.parent = middle;        }        return middle;    }

上面代码即通过传入一个有序的集合，来构造一个TreeMap，由于是有序集合，所以肯定是从二叉树的两头开始构造的。

getEntry方法

即通过一个key，获取key属于的那个节点。

    /**     * 从实体中寻找key，默认是没有有comparator的。     * 就使用默认的compareTo来进行比较。     *      * 由此可知，key不能为null。     */    final Entry<K,V> getEntry(Object key) {        // Offload comparator-based version for sake of performance        if (comparator != null)            return getEntryUsingComparator(key);        if (key == null)            throw new NullPointerException();        @SuppressWarnings("unchecked")            Comparable<? super K> k = (Comparable<? super K>) key;        Entry<K,V> p = root;        while (p != null) {            int cmp = k.compareTo(p.key);            if (cmp < 0)                p = p.left;            else if (cmp > 0)                p = p.right;            else                return p;        }        return null;    }

getEntry方法只涉及二叉树的查找，所以不涉及调整，即从根节点开始一直向下查找。这段相关代码在上面将键是否为null时列举出来过，就不多讲了。
在二叉树结构的TreeMap中，并不是每次都能找到值，所以在TreeMap中，还提供了很多get方法，例如：
final Entry

/** * 天花板，所以在上面，所以比k大的最小 *      找到一个，比key大的，最小的节点，可以等于k，获取TreeMap中不小于key的最小的节点；     若不存在(即TreeMap中所有节点的键都比key大)，就返回null * @param key * @return */    final Entry<K,V> getCeilingEntry(K key) {        Entry<K,V> p = root;        while (p != null) {            int cmp = compare(key, p.key);            // 情况一：若“p的key” > key。            // 若 p 存在左孩子，则设 p=“p的左孩子”；            // 否则，返回p            if (cmp < 0) {                if (p.left != null)                    p = p.left;                else                    return p;            // 情况二：若“p的key” < key。            } else if (cmp > 0) {                // 若 p 存在右孩子，则设 p=“p的右孩子”                if (p.right != null) {                    p = p.right;                } else {                    // 若 p 不存在右孩子，则找出 p 的后继节点，并返回                    // 注意：这里返回的 “p的后继节点”有2种可能性：第一，null；第二，TreeMap中大于key的最小的节点。                    //   理解这一点的核心是，getCeilingEntry是从root开始遍历的。                    //   若getCeilingEntry能走到这一步，那么，它之前“已经遍历过的节点的key”都 > key。                    //   能理解上面所说的，那么就很容易明白，为什么“p的后继节点”又2种可能性了。                    Entry<K,V> parent = p.parent;                    Entry<K,V> ch = p;                    while (parent != null && ch == parent.right) {                        ch = parent;                        parent = parent.parent;                    }                    return parent;                }            // 情况三：若“p的key” = key。            } else                return p;        }        return null;    }  

put方法

put方法步骤，先向下找最适合本(key，value)对的地方，然后插入，最后调整

    /**     * 将一对键值对k，v插入到treemap中，如果k已经存在，则会发生替换，value将替换oldvalue     */    public V put(K key, V value) {        Entry<K,V> t = root;        if (t == null) {            //检查是否为null            compare(key, key); // type (and possibly null) check            root = new Entry<>(key, value, null);            size = 1;            modCount++;            return null;        }        int cmp;        Entry<K,V> parent;        // 左右两条线，向下的查找        Comparator<? super K> cpr = comparator;        if (cpr != null) {            do {                parent = t;                cmp = cpr.compare(key, t.key);                if (cmp < 0)                    t = t.left;                else if (cmp > 0)                    t = t.right;                else                    return t.setValue(value);            } while (t != null);        }        else {            if (key == null)                throw new NullPointerException();            @SuppressWarnings("unchecked")                Comparable<? super K> k = (Comparable<? super K>) key;            do {                parent = t;                cmp = k.compareTo(t.key);                if (cmp < 0)                    t = t.left;                else if (cmp > 0)                    t = t.right;                else                    return t.setValue(value);            } while (t != null);        }        //找到了最佳的位置        Entry<K,V> e = new Entry<>(key, value, parent);        if (cmp < 0)            parent.left = e;        else            parent.right = e;        //插入后的调整        fixAfterInsertion(e);        size++;        modCount++;        return null;    }

delete方法

相比较与put方法来说，delete方法并不用再进行寻找节点，因为已经给了你这个节点了，当然有些方法如果只提供key的话，就还需要找到这个节点。

/**     * 删除p，然后重新调整平衡     */    private void deleteEntry(Entry<K,V> p) {        modCount++;        size--;        // p有两个孩子节点        if (p.left != null && p.right != null) {            Entry<K,V> s = successor(p);            p.key = s.key;            p.value = s.value;            p = s;        } // p has 2 children        // 选取替代将要删除节点位置节点        Entry<K,V> replacement = (p.left != null ? p.left : p.right);        if (replacement != null) {            replacement.parent = p.parent;            if (p.parent == null)                root = replacement;            else if (p == p.parent.left)                p.parent.left  = replacement;            else                p.parent.right = replacement;            p.left = p.right = p.parent = null;            if (p.color == BLACK)                fixAfterDeletion(replacement);        } else if (p.parent == null) { // return if we are the only node.            root = null;        } else {             if (p.color == BLACK)                //删除后的调整                fixAfterDeletion(p);            if (p.parent != null) {                if (p == p.parent.left)                    p.parent.left = null;                else if (p == p.parent.right)                    p.parent.right = null;                p.parent = null;            }        }    }

TreeMap里面的Iterator

首先，TreeMap里面的Iterator也是fail-fast的。这里要注意一点，在Map里面的集合中，遍历操作只能通过Iterator来实现，因为Map里面不是线性表，所以你自然不能用类似于ArrayList等for循环走一遍就遍历到所有操作。
TreeMap里面有多个不同实现的Iterator
static class TreeMapSpliterator<K,V>：在TreeMap的Iterator中作为下面两个Iterator的父类，实现公共的Spliterater方法。
static final class KeySpliterator<K,V>：key的分割迭代器。
static final class DescendingKeySpliterator<K,V>：倒序的key的分割迭代器。

本文图片以及红黑树学习引用于：
julycoding