《Java源码分析》：TreeMap

《Java源码分析》：TreeMap

今天把TreeMap的源码稍微看了下，TreeMap的内部是基于红黑树来完成的。

由于红黑树确实在我们的实际编码过程中用的比较少，因此自己对红黑树的认知不是很深，只是稍微有点印象罢了。

由于TreeMap是基于红黑树来完成，因此 ，首先先列出红黑树的5个性质：

性质 1：每个节点要么是红色，要么是黑色。

性质 2：根节点永远是黑色的。

性质 3：所有的叶节点都是空节点（即 null），并且是黑色的。

性质 4：每个红色节点的两个子节点都是黑色。（从每个叶子到根的路径上不会有两个连续的红色节点）

性质 5：从任一节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点。

本文只是对TreeMap的源码进行简单的分析，并没有去仔仔细细的研究红黑树的”插入元素”、”删除元素”的结构的调整和调色。

1、TreeMap的继承体系结构

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

上面只有一个接口需要说明，那就是NavigableMap接口。

public interface NavigableMap<K,V> extends SortedMap<K,V> 

NavigableMap接口扩展的SortedMap，具有了针对给定搜索目标返回最接近匹配项的导航方法。
方法lowerEntry、floorEntry、ceilingEntry和higherEntry分别返回与小于、小于等于、大于等于、大于给定键的键关联的Map.Entry对象，
如果不存在这样的键，则返回null。类似地，方法lowerKey、floorKey、ceilingKey和higherKey只返回关联的键。所有这些方法是为查找条目而不是遍历条目而设计的。

2、TreeMap的相关属性介绍

TreeMap中相关属性和Entry类的一个介绍

    //此比较器被用来维持tree map中元素的顺序，如果为null，则用key的自然顺序来进行排序
    private final Comparator<? super K> comparator;
    // 根节点
    private transient Entry<K,V> root;

    // 树中的节点数量
    private transient int size = 0;
    //用于记录结构的改变次数
    private transient int modCount = 0;

TreeMap类中Entry内部类介绍，从Entry类就可以看出，TreeMap是基于红黑树实现的哈。Entry类的代码也比较简单。

    private static final boolean RED   = false;
    private static final boolean BLACK = true;

    /**
     * Node in the Tree.  Doubles as a means to pass key-value pairs back to
     * user (see Map.Entry).
     */
    //TreeMap的内部实现结构：红黑树
    static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;
        V value;
        Entry<K,V> left;
        Entry<K,V> right;
        Entry<K,V> parent;
        boolean color = BLACK;

        /**
         * Make a new cell with given key, value, and parent, and with
         * {@code null} child links, and BLACK color.
         */
        //根据key、value和parent来创建一个节点对象，颜色为BLACK.
        Entry(K key, V value, Entry<K,V> parent) {
            this.key = key;
            this.value = value;
            this.parent = parent;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        public V setValue(V value) {
            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }
        // 判断节点相等的方法（两个节点为同一类型且key值和value值都相等时两个节点相等）
        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;

            return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
        }
        // 节点的哈希值计算方法
        public int hashCode() {
            int keyHash = (key==null ? 0 : key.hashCode());
            int valueHash = (value==null ? 0 : value.hashCode());
            return keyHash ^ valueHash;
        }

        public String toString() {
            return key + "=" + value;
        }
    }

3、TreeMap类的构造方法介绍

TreeMap类相关构造方法介绍，主要有如下两个构造方法。

1、说明：构造一个新的，空的TreeMap对象，应用key的自然顺序对其排序。keys必须实现了Comparable接口。而且，所有的key必须能够互相比较(即：k1.compareTo(k2))。即不能抛ClassCastException(类型转换异常)。

    public TreeMap() {
        comparator = null;
    }

2、说明：构造一个新的，空的TreeMap对象，根据指定的Comparator来进行排序。
所有的key必须能够用指定的Comparator进行互相比较(即：comparator.compare(k1,k2))。即不能抛ClassCastException(类型转换异常)。

    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }

4、TreeMap的put(key,val)介绍

put方法的代码如下：

    public V put(K key, V value) {
        Entry<K,V> t = root;
        //如果根节点为null，则
        if (t == null) {
            //类型检查，如果k1或k2如果为null，则会抛出NullPointerException异常
            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实现在root为根节点移动寻找传入键值对需要插入的位置
            do {
                parent = t;
                // 使用比较器比较插入键值对的key值与父节点t.key的大小
                cmp = cpr.compare(key, t.key); 
                if (cmp < 0) //如果小于父节点t的值，由于红黑树是一个自平衡二叉搜索树，因此，继续递归到父节点左节点
                    t = t.left;
                else if (cmp > 0)//如果大于父节点t的值，由于红黑树是一个自平衡二叉搜索树，因此，继续递归到父节点右节点
                    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;
            // 比较插入键值对的key值与父节点t.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);
        //根据比较值来把此节点设置为parent的左节点还是右节点
        if (cmp < 0)//如果小于parent节点，则放在左节点
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);//插入元素之后要修正，保持红黑树的5点性质
        size++;
        modCount++;
        return null;
    }

    //一些小工具方法

    /**
     * Compares two keys using the correct comparison method for this TreeMap.
     */
    //在TreeMap中使用正确的比较器比较两个key的大小
    @SuppressWarnings("unchecked")
    final int compare(Object k1, Object k2) {
        //如果k1或k2如果为null，则会抛出NullPointerException异常
        return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2) 
            : comparator.compare((K)k1, (K)k2);
    }

put(key,value)方法的思路比较简单，如下两个步骤

1、根据key先在红黑树中找出其即将要插入的位置，并插入到树中

2、由于添加节点会破坏红黑树，因此在插入元素之后要进行修正（颜色转换和数旋转），保持红黑树的5点性质。

插入后的修复

在插入操作中，红黑树的性质 1 和性质 3 两个永远不会发生改变，因此无需考虑红黑树的这两个特性。
这种颜色调用和树旋转就比较复杂了，下面将分情况进行介绍。在介绍中，我们把新插入的节点定义为 N 节点，N 节点的父节点定义为 P 节点，P 节点的兄弟节点定义为 U 节点，P 节点父节点定义为 G 节点。

红黑树在插入元素之后，要进行调整确实比较复杂，有如下5中情况：

情形 1：新节点 N 是树的根节点，没有父节点

在这种情形下，直接将它设置为黑色以满足性质 2。

情形 2：新节点的父节点 P 是黑色

在这种情况下，新插入的节点是红色的，因此依然满足性质 4。而且因为新节点 N 有两个黑色叶子节点；但是由于新节点 N 是红色，通过它的每个子节点的路径依然保持相同的黑色节点数，因此依然满足性质 5。

情形 3：如果父节点 P 和父节点的兄弟节点 U 都是红色

在这种情况下，程序应该将 P 节点、U 节点都设置为黑色，并将 P 节点的父节点设为红色（用来保持性质 5）。现在新节点 N 有了一个黑色的父节点 P。由于从 P 节点、U 节点到根节点的任何路径都必须通过 G 节点，在这些路径上的黑节点数目没有改变（原来有叶子和 G 节点两个黑色节点，现在有叶子和 P 两个黑色节点）。
经过上面处理后，红色的 G 节点的父节点也有可能是红色的，这就违反了性质 4，因此还需要对 G 节点递归地进行整个过程（把 G 当成是新插入的节点进行处理即可）。

情形 4：父节点 P 是红色、而其兄弟节点 U 是黑色或缺少；且新节点 N 是父节点 P 的右子节点，而父节点 P 又是其父节点 G 的左子节点。

在这种情形下，我们进行一次左旋转对新节点和其父节点进行，接着按情形 5 处理以前的父节点 P（也就是把 P 当成新插入的节点即可）。这导致某些路径通过它们以前不通过的新节点 N 或父节点 P 的其中之一，但是这两个节点都是红色的，因此不会影响性质 5。

情形 5：父节点 P 是红色、而其兄弟节点 U 是黑色或缺少；且新节点 N 是其父节点的左子节点，而父节点 P 又是其父节点 G 的左子节点。

在这种情形下，需要对节点 G 的一次右旋转，在旋转产生的树中，以前的父节点 P 现在是新节点 N 和节点 G 的父节点。由于以前的节点 G 是黑色，否则父节点 P 就不可能是红色，我们切换以前的父节点 P 和节点 G 的颜色，使之满足性质 4，性质 5 也仍然保持满足，因为通过这三个节点中任何一个的所有路径以前都通过节点 G，现在它们都通过以前的父节点 P。在各自的情形下，这都是三个节点中唯一的黑色节点。

上面摘入至：
1、http://www.ibm.com/developerworks/cn/java/j-lo-tree/

2、http://blog.csdn.net/chenhuajie123/article/details/11951777

插入元素之后修正的函数为：fixAfterInsertion(Entry

    /** From CLR */
    private void fixAfterInsertion(Entry<K,V> x) {
        // 将插入节点的颜色设置为红色
        x.color = RED;
        // 循环条件是x不为空且不是根节点且父节点的颜色是红色（如果父节点不是红色，则没有连续的红色节点，不再调整）
        //情形一：如果x是root节点，则不需要调整了，只需要设置为黑色即可
        while (x != null && x != root && x.parent.color == RED) {
            /*
                以下所有情况都是x的父节点的颜色为红色，牢记！！！
            */
            //如果x的父节点是x的父节点的父节点的左节点
            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
                // 获取 x 的父节点的兄弟节点
                Entry<K,V> y = rightOf(parentOf(parentOf(x)));
                // 情形三：如果 x 的父节点的兄弟节点是红色，即父节点P和父节点的兄弟节点y都是红色
                if (colorOf(y) == RED) {
                    // 将 x 的父节点设为黑色
                    setColor(parentOf(x), BLACK);
                    // 将 x 的父节点的兄弟节点设为黑色
                    setColor(y, BLACK);
                     // 将 x 的父节点的父节点设为红色
                    setColor(parentOf(parentOf(x)), RED);
                    //递归地进行整个过程，把parentOf(parentOf(x))当成是新插入的节点进行处理即可
                    x = parentOf(parentOf(x));
                } else {
                    //情形四：如果 x 的父节点的兄弟节点是黑色或者缺少，且x为父节点的右节点
                    if (x == rightOf(parentOf(x))) {
                        //左旋转
                        x = parentOf(x);
                        rotateLeft(x);
                    }
                    //情形 5：父节点 P 是红色、而其兄弟节点 U 是黑色或缺少；且新节点 x 是其父节点的左子节点，而父节点 P 又是其父节点 PP的左子节点。
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateRight(parentOf(parentOf(x)));
                }
            } else {//如果x的父节点是x的父节点的父节点的右节点

                // 获取 x 的父节点的兄弟节点
                Entry<K,V> y = leftOf(parentOf(parentOf(x)));
                //情形三：(同上) x的父节点的兄弟节点为红色，即x的父节点P和P的兄弟节点均为红色
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    //情形四：如果 x 的父节点的兄弟节点是黑色或者缺少，且x为父节点的左节点
                    if (x == leftOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateRight(x);//右旋
                    }
                     // 把 x 的父节点设为黑色
                    setColor(parentOf(x), BLACK);
                    // 把 x 的父节点的父节点设为红色
                    setColor(parentOf(parentOf(x)), RED);
                    //左旋
                    rotateLeft(parentOf(parentOf(x)));
                }
            }
        }
        root.color = BLACK;
    }
    //函数功能：获取节点p的父节点。
    private static <K,V> Entry<K,V> parentOf(Entry<K,V> p) {
        return (p == null ? null: p.parent);
    }
    //函数功能：获取节点p的左节点
    private static <K,V> Entry<K,V> leftOf(Entry<K,V> p) {
        return (p == null) ? null: p.left;
    }
    //函数功能：获取节点p的右节点
    private static <K,V> Entry<K,V> rightOf(Entry<K,V> p) {
        return (p == null) ? null: p.right;
    }

5、TreeMap的get方法介绍

get方法的源码如下：

    public V get(Object key) {
        Entry<K,V> p = getEntry(key);
        return (p==null ? null : p.value);
    }

get方法的实现比较简单：就是根据二叉搜索树的性质来找出符合要求的结点。然后返回value即可。

getEntry(Object key)方法的代码如下：(注释相当仔细，代码也比较简单)

     //函数功能：根据给定的key在Map找出符合要求的Entry，如果在Map中不包含则返回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;
        //从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(Object key)中如果指定了比较器comparator则调用了getEntryUsingComparator(key)方法，源码如下：

    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;
    }

函数功能：getEntryUsingComparator(Object key)根据比较器在TreeMap中遍历寻找，实现思路与上面的getEntry(Object key)实现思路一致。

6、TreeMap类中remove(Object key)方法的介绍

TreeMap类中put(key,value)中在添加元素中之后需要对树进行旋转和调色。同样，删除一个元素也需要对树进行旋转和调色。

remove(Object key)方法的源码如下：

    //在TreeMap中移除指定key的Entry 
    public V remove(Object key) {
        //先找出指定key的Entry
        Entry<K,V> p = getEntry(key);
        if (p == null) //如果为null，则返回
            return null;

        V oldValue = p.value;
        deleteEntry(p);
        return oldValue;
    }

remove(Object key)中先根据key在树中找到其所在的结点。然后调用deleteEntry(Entry

     //删除节点p,并调整树
    private void deleteEntry(Entry<K,V> p) {
        modCount++;
        size--;

        // If strictly internal, copy successor's element to p and then make p
        // point to successor.
        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

        // Start fixup at replacement node, if it exists.
        Entry<K,V> replacement = (p.left != null ? p.left : p.right);

        if (replacement != null) {
            // Link replacement to parent
            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;

            // Null out links so they are OK to use by fixAfterDeletion.
            p.left = p.right = p.parent = null;

            // Fix replacement
            if (p.color == 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)
                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 删除节点之后也需要进行类似的修复操作，通过这种修复来保证该排序二叉树依然满足红黑树特征。大家可以参考插入节点之后的修复来分析删除之后的修复。TreeMap 在删除之后的修复操作由 fixAfterDeletion(Entry

     // 删除节点后修复红黑树
     private void fixAfterDeletion(Entry<K,V> x) 
     { 
        // 直到 x 不是根节点，且 x 的颜色是黑色
        while (x != root && colorOf(x) == BLACK) 
        { 
            // 如果 x 是其父节点的左子节点
            if (x == leftOf(parentOf(x))) 
            { 
                // 获取 x 节点的兄弟节点
                Entry<K,V> sib = rightOf(parentOf(x)); 
                // 如果 sib 节点是红色
                if (colorOf(sib) == RED) 
                { 
                    // 将 sib 节点设为黑色
                    setColor(sib, BLACK); 
                    // 将 x 的父节点设为红色
                    setColor(parentOf(x), RED); 
                    rotateLeft(parentOf(x)); 
                    // 再次将 sib 设为 x 的父节点的右子节点
                    sib = rightOf(parentOf(x)); 
                } 
                // 如果 sib 的两个子节点都是黑色
                if (colorOf(leftOf(sib)) == BLACK 
                    && colorOf(rightOf(sib)) == BLACK) 
                { 
                    // 将 sib 设为红色
                    setColor(sib, RED); 
                    // 让 x 等于 x 的父节点
                    x = parentOf(x); 
                } 
                else 
                { 
                    // 如果 sib 的只有右子节点是黑色
                    if (colorOf(rightOf(sib)) == BLACK) 
                    { 
                        // 将 sib 的左子节点也设为黑色
                        setColor(leftOf(sib), BLACK); 
                        // 将 sib 设为红色
                        setColor(sib, RED); 
                        rotateRight(sib); 
                        sib = rightOf(parentOf(x)); 
                    } 
                    // 设置 sib 的颜色与 x 的父节点的颜色相同
                    setColor(sib, colorOf(parentOf(x))); 
                    // 将 x 的父节点设为黑色
                    setColor(parentOf(x), BLACK); 
                    // 将 sib 的右子节点设为黑色
                    setColor(rightOf(sib), BLACK); 
                    rotateLeft(parentOf(x)); 
                    x = root; 
                } 
            } 
            // 如果 x 是其父节点的右子节点
            else 
            { 
                // 获取 x 节点的兄弟节点
                Entry<K,V> sib = leftOf(parentOf(x)); 
                // 如果 sib 的颜色是红色
                if (colorOf(sib) == RED) 
                { 
                    // 将 sib 的颜色设为黑色
                    setColor(sib, BLACK); 
                    // 将 sib 的父节点设为红色
                    setColor(parentOf(x), RED); 
                    rotateRight(parentOf(x)); 
                    sib = leftOf(parentOf(x)); 
                } 
                // 如果 sib 的两个子节点都是黑色
                if (colorOf(rightOf(sib)) == BLACK 
                    && colorOf(leftOf(sib)) == BLACK) 
                { 
                    // 将 sib 设为红色
                    setColor(sib, RED); 
                    // 让 x 等于 x 的父节点
                    x = parentOf(x); 
                } 
                else 
                { 
                    // 如果 sib 只有左子节点是黑色
                    if (colorOf(leftOf(sib)) == BLACK) 
                    { 
                        // 将 sib 的右子节点也设为黑色
                        setColor(rightOf(sib), BLACK); 
                        // 将 sib 设为红色
                        setColor(sib, RED); 
                        rotateLeft(sib); 
                        sib = leftOf(parentOf(x)); 
                    } 
                    // 将 sib 的颜色设为与 x 的父节点颜色相同
                    setColor(sib, colorOf(parentOf(x))); 
                    // 将 x 的父节点设为黑色
                    setColor(parentOf(x), BLACK); 
                    // 将 sib 的左子节点设为黑色
                    setColor(leftOf(sib), BLACK); 
                    rotateRight(parentOf(x)); 
                    x = root; 
                } 
            } 
        } 
        setColor(x, BLACK); 
     }

小结

以上就是关于TreeMap的一个简单介绍。自己也是大概看了下TreeMap的实现，红黑树的具体细节自己并没有仔细研究。关于TreeMap类我们需要记住的是其底层实现是基于“红黑树”来实现的就可以了。

参考资料

1、http://www.ibm.com/developerworks/cn/java/j-lo-tree/

2、http://blog.csdn.net/jzhf2012/article/details/8540705

3、http://blog.csdn.net/chenhuajie123/article/details/11951777