TreeMap源码解析

疑问：TreeMap的clear()方法与LinkedList,ArrayList,HashMapd等的比较

一、定义

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

TreeMap扩展自AbstractMap
实现NavigableMap
实现Cloneable，实现Serializable
来看下NavigableMap

public interface SortedMap<K,V> extends Map<K,V> {    Comparator<? super K> comparator();    //返回formKey到toKey(不包括)间的视图    SortedMap<K,V> subMap(K fromKey, K toKey);    //返回小于toKey的视图    SortedMap<K,V> headMap(K toKey);    //返回小于tailMap的视图    SortedMap<K,V> tailMap(K fromKey);    //返回first key    K firstKey();    //返回last key    K lastKey();    //返回key视图，与SortMap存在映射关系，修改set<K>或SortedMap中的一个，另一个也会改变    Set<K> keySet();    Collection<V> values();    Set<Map.Entry<K, V>> entrySet();}public interface NavigableMap<K,V> extends SortedMap<K,V> {    Map.Entry<K,V> lowerEntry(K key);    K lowerKey(K key);    Map.Entry<K,V> floorEntry(K key);    K floorKey(K key);    Map.Entry<K,V> ceilingEntry(K key);    K ceilingKey(K key);    Map.Entry<K,V> higherEntry(K key);    K higherKey(K key);    Map.Entry<K,V> firstEntry();    Map.Entry<K,V> lastEntry();    Map.Entry<K,V> pollFirstEntry();    Map.Entry<K,V> pollLastEntry();    //返回逆序视图    NavigableMap<K,V> descendingMap();    NavigableSet<K> navigableKeySet();    //逆序key视图    NavigableSet<K> descendingKeySet();    //根据formInclusive判断返图视图是否包含formKey    //根据toInclusive判断返图视图是否包含toKey    NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,                             K toKey,   boolean toInclusive);    //根据toInclusive判断返图视图是否包含toKey    NavigableMap<K,V> headMap(K toKey, boolean inclusive);    NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);    SortedMap<K,V> subMap(K fromKey, K toKey);    SortedMap<K,V> headMap(K toKey);    SortedMap<K,V> tailMap(K fromKey);}

SortMap和SortedMap提供了一些排序需要基本方法。

二、底层
红黑树
恶补这块花费了很久时间。。
理解红黑树的时候有个坑，在这里记录一下：TreeMap中的红黑树叶节点都是空节点，都不存储数据，只要不是叶节点都会存储数据。
三、构造器及常量

//comparator比较器，为null时，按照自然顺序排序    private final Comparator<? super K> comparator;    //根root    private transient Entry<K,V> root = null;    //size    private transient int size = 0;    //多线程是舒勇    private transient int modCount = 0;    //空tree，自然顺序排序    public TreeMap() {        comparator = null;    }    //空tree,通过comparator来比较    public TreeMap(Comparator<? super K> comparator) {        this.comparator = comparator;    }    //tree中m包含entry，entrys按照自然排序重新进行排序，    //运行时间为 n*log(n)。     public TreeMap(Map<? extends K, ? extends V> m) {        comparator = null;        putAll(m);    }    //运行时间n    //生成TreeMap的结构满足平衡二叉树，可能和m的结构不一致    public TreeMap(SortedMap<K, ? extends V> m) {        comparator = m.comparator();        try {            buildFromSorted(m.size(), m.entrySet().iterator(), null, null);        } catch (java.io.IOException cannotHappen) {        } catch (ClassNotFoundException cannotHappen) {        }    }    //通过递归生成一个平衡二叉树    //生产二叉树的结构：最高层节点颜色都为red，其余black    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);    }    /*     * 通过递归获取从lo-hi见的节点树，返回树的跟     */    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 {        /*         * Strategy: The root is the middlemost element. To get to it, we         * have to first recursively construct the entire left subtree,         * so as to grab all of its elements. We can then proceed with right         * subtree.         *         * The lo and hi arguments are the minimum and maximum         * indices to pull out of the iterator or stream for current subtree.         * They are not actually indexed, we just proceed sequentially,         * ensuring that items are extracted in corresponding order.         */        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);        // extract key and/or value from iterator or stream        K key;        V value;        if (it != null) {//存在迭代器，通过迭代器录入数据            if (defaultVal==null) {                //val为空，说明it类型为Entry，通过Entry获得value值                Map.Entry<K,V> entry = (Map.Entry<K,V>)it.next();                key = entry.getKey();                value = entry.getValue();            } else {                //val不为空，value直接赋值                key = (K)it.next();                value = defaultVal;            }        } else { //通过流取值            key = (K) str.readObject();            value = (defaultVal != null ? defaultVal : (V) str.readObject());        }        Entry<K,V> middle =  new Entry<>(key, value, null);        // level == redLevel ，则此时的结点为红色         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;    }    //获取叶子节点的层数    private static int computeRedLevel(int sz) {        int level = 0;        for (int m = sz - 1; m >= 0; m = m / 2 - 1)            level++;        return level;    }

三、put，get、remove

    public V get(Object key) {        Entry<K,V> p = getEntry(key);        return (p==null ? null : p.value);    }    final Entry<K,V> getEntry(Object key) {        // 按自然顺序排序时，调用getEntryUsingComparator，两者的性能并没有差异        if (comparator != null)            return getEntryUsingComparator(key);        if (key == null)            throw new NullPointerException();        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;    public void putAll(Map<? extends K, ? extends V> map) {        int mapSize = map.size();        if (size==0 && mapSize!=0 && map instanceof SortedMap) {            Comparator c = ((SortedMap)map).comparator();            if (c == comparator || (c != null && c.equals(comparator))) {                ++modCount;                try {                    buildFromSorted(mapSize, map.entrySet().iterator(),                                    null, null);                } catch (java.io.IOException cannotHappen) {                } catch (ClassNotFoundException cannotHappen) {                }                return;            }        }        super.putAll(map);    }    //do-wile的典型用法哦    public V put(K key, V value) {        Entry<K,V> t = root;        //第一种情况，tree为空        if (t == 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;        // split comparator and comparable paths        Comparator<? super K> cpr = comparator;        //找到插入节点的位置        if (cpr != null) {            //使用do-while,因为上面已经比较t==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();            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);        //将e插入到tree中，然后进行调整        if (cmp < 0)            parent.left = e;        else            parent.right = e;        fixAfterInsertion(e);        size++;        modCount++;        return null;    }     /**     * 求t的下一个节点，     */    static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {        if (t == null)            return null;        //当t有右子节点时，t的下一个节点在以t.right为根的树中        else if (t.right != null) {            Entry<K,V> p = t.right;            while (p.left != null)                p = p.left;            return p;        //t没有右子节点,t的下一个节点在为t的父辈节点中        } else {            Entry<K,V> p = t.parent;            Entry<K,V> ch = t;            //parent = null,遍历完成,没有next值            //p.parent.right = p 时，说明t.parent < p,需要继续向上遍历            while (p != null && ch == p.right) {                ch = p;                p = p.parent;            }            return p;        }    }    private void rotateLeft(Entry<K,V> p) {        if (p != null) {            Entry<K,V> r = p.right;            //右节点指向右节点。left            p.right = r.left;            if (r.left != null)                //右节点。left.parent指向p                r.left.parent = p;            //右节点。parent指向p，parent            r.parent = p.parent;            if (p.parent == null)                //P为根节点，跟节点为右节点                root = r;            else if (p.parent.left == p)                //将父节点指向p改为指向右节点                p.parent.left = r;            else                p.parent.right = r;            //右节点。left指向p            r.left = p;            //p.parent指向右节点            p.parent = r;        }    }    /** From CLR */    //设计很灵巧，自己的想法是一直判断，需要的时候递归，或者像责任链模式那样逐层像下    //第五种情况和第四种情况直接写在一个代码块中，第五种情况右单独写在一个if代码块中，    //这样的化，如果是第五种情况，执行if代码块后，变为第四种情况，直接执行第四种情况的代码块，    //操作时，颜色调整log(n)此，旋转最多2次    private void fixAfterInsertion(Entry<K,V> x) {        x.color = RED;        //第二种情况 父节点black时，不需要改变        //第三、四。。情况下父节点red，祖父节点一定为black        //只有第三中情况会进行循环        //x==null表明： 上次循环时，x.parant为root 循环结束        //x==root 循环结束        while (x != null && x != root && x.parent.color == RED) {            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {                Entry<K,V> y = rightOf(parentOf(parentOf(x)));                if (colorOf(y) == RED) {                    //第三种情况：父节点为祖父节点的左子节点，且叔节点red                    //此时改变父节点、叔节点、祖父节点颜色，以祖父节点为根的子树符合标准，继续递归                    setColor(parentOf(x), BLACK);                    setColor(y, BLACK);                    setColor(parentOf(parentOf(x)), RED);                    x = parentOf(parentOf(x));                } else {                    if (x == rightOf(parentOf(x))) {                        //第五中情况：父节点为祖父节点的左子节点，且叔节点black,节点为父节点的右节点几点                        //此时以父节点左旋，将节点重新赋值为父节点，变为第4种情况，                        //然后直接执行第四种情况的操作                        x = parentOf(x);                        rotateLeft(x);                    }                    //第四种情况：父节点为祖父节点的左子节点，且叔节点black,节点为父节点的左几点                    //此时以祖父节点右旋，然后改变节点颜色，完成                    setColor(parentOf(x), BLACK);                    setColor(parentOf(parentOf(x)), RED);                    rotateRight(parentOf(parentOf(x)));                }            } else {                Entry<K,V> y = leftOf(parentOf(parentOf(x)));                if (colorOf(y) == RED) {                    setColor(parentOf(x), BLACK);                    setColor(y, BLACK);                    setColor(parentOf(parentOf(x)), RED);                    x = parentOf(parentOf(x));                } else {                    if (x == leftOf(parentOf(x))) {                        x = parentOf(x);                        rotateRight(x);                    }                    setColor(parentOf(x), BLACK);                    setColor(parentOf(parentOf(x)), RED);                    rotateLeft(parentOf(parentOf(x)));                }            }        }        root.color = BLACK;    }    public V remove(Object key) {        Entry<K,V> p = getEntry(key);        if (p == null)            return null;        V oldValue = p.value;        deleteEntry(p);        return oldValue;    }    /**     * 第三种情况右疑问     *      * 颜色转换log(n)，旋转最多3次     *      * 将调整删除节点后的调整 和 第三种情况，未删除节点前直接调整，放在同一个方法中，难理解     */    private void deleteEntry(Entry<K,V> p) {        modCount++;        size--;        //第六种情况：拥有两个节点，与节点的next互换位置后，变为第2-5钟情况        //只喜欢key,value值，其他值保留        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) {            //第四种情况：拥有一个子节点，且节点red            //直接删除节点            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;            // Fix replacement            if (p.color == BLACK)                //第五种情况：拥有一个子节点，且节点black                //删除节点，然后进行调整                fixAfterDeletion(replacement);        } else if (p.parent == null) { // return if we are the only node.            //第一种情况： 只有一个节点            root = null;        } else { //  No children. Use self as phantom replacement and unlink.            if (p.color == BLACK)                //第三种情况，没有子节点，且节点black                //通过调整，调整后变为第二种情况                //但是，p的指针指向不是变为root了吗？？                fixAfterDeletion(p);            if (p.parent != null) {                //第二种情况，没有子节点，且节点red                //此时，直接删除节点                if (p == p.parent.left)                    p.parent.left = null;                else if (p == p.parent.right)                    p.parent.right = null;                p.parent = null;            }        }    }    /** From CLR */    //通过调整使x.parent到x下面节点路径上的黑节点数都增加1    private void fixAfterDeletion(Entry<K,V> x) {        while (x != root && colorOf(x) == BLACK) {            if (x == leftOf(parentOf(x))) {                Entry<K,V> sib = rightOf(parentOf(x));                if (colorOf(sib) == RED) {                    //第一种情况：兄弟节点red,则其他节点都black                    //以父节点，左旋，改变父节点red，兄弟节点black,变为第三、四、五种情况                    setColor(sib, BLACK);                    setColor(parentOf(x), RED);                    rotateLeft(parentOf(x));                    sib = rightOf(parentOf(x));                }                if (colorOf(leftOf(sib))  == BLACK &&                    colorOf(rightOf(sib)) == BLACK) {                    //第二种情况，兄弟节点black,兄弟节点两个子节点black                    //改变兄弟节点red，此时父节点为根的子树，都少一个黑节点，继续递归                    setColor(sib, RED);                    x = parentOf(x);                } else {                    if (colorOf(rightOf(sib)) == BLACK) {                        //第四种情况，兄弟节点black，兄弟节点的左子节点red,右子节点blac                        //改变兄弟节点的左子节点black,兄弟节点red,以兄弟节点右旋，变为第五种情况                        setColor(leftOf(sib), BLACK);                        setColor(sib, RED);                        rotateRight(sib);                        sib = rightOf(parentOf(x));                    }                    //第五种情况：兄节点black,兄节点的右子节点red，左子节点black                    //兄弟节点颜色改变为父节点颜色，父节点颜色black,兄节点的右子节点red，以父节点左旋，完成                    setColor(sib, colorOf(parentOf(x)));                    setColor(parentOf(x), BLACK);                    setColor(rightOf(sib), BLACK);                    rotateLeft(parentOf(x));                    x = root;                }            } else { // symmetric                Entry<K,V> sib = leftOf(parentOf(x));                if (colorOf(sib) == RED) {                    setColor(sib, BLACK);                    setColor(parentOf(x), RED);                    rotateRight(parentOf(x));                    sib = leftOf(parentOf(x));                }                if (colorOf(rightOf(sib)) == BLACK &&                    colorOf(leftOf(sib)) == BLACK) {                    setColor(sib, RED);                    x = parentOf(x);                } else {                    if (colorOf(leftOf(sib)) == BLACK) {                        setColor(rightOf(sib), BLACK);                        setColor(sib, RED);                        rotateLeft(sib);                        sib = leftOf(parentOf(x));                    }                    setColor(sib, colorOf(parentOf(x)));                    setColor(parentOf(x), BLACK);                    setColor(leftOf(sib), BLACK);                    rotateRight(parentOf(x));                    x = root;                }            }        }        //？？        setColor(x, BLACK);    }

五、clear

/**     * 直接root变为null,其他交给gc     * 为什么不逐个元素清空？他们之间也有引用     * 虚拟机基本了解后再来解决吧     */    public void clear() {        modCount++;        size = 0;        root = null;    }

六、内部类
TreeMap的内部类特别多


Entry:基本元素类
Values,KeySet,EntrySet: 用于生成集合，多数方式都是通过代理利用外部类的方法。
PrivateEntryIterator,KeyIterator,ValueIterator,EntryIterator,DescendingKeyIterator：迭代器类
SubMap：为了与以前的代码兼容
NavigableSubMap、AscendingSubMap、DescendingSubMap： 为了生成subMap，AscendingSubMap、DescendingSubMap继承与NavigableSubMap，NavigableSubMap基本实现了TreeMap的所有功能，并且嵌套了更多的静态内部类

红黑树看的头疼。。

参考：http://blog.csdn.net/jzhf2012/article/details/8540713
http://blog.csdn.net/jiang_bing/article/details/7537803
https://zh.wikipedia.org/wiki/%E7%BA%A2%E9%BB%91%E6%A0%91
http://yikun.github.io/2015/04/06/Java-TreeMap%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E5%8F%8A%E5%AE%9E%E7%8E%B0/