容器源码分析之TreeMap(十)

1.TreeMap的结构

我们知道，TreeMap的内部实现就是一个红黑树。

关于红黑树的介绍，建议大家先看看这里
红黑树的原理和算法详细介绍

2.TreeMap的继承关系

-

3.TreeMap的成员变量

public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable {
     // Key的比较器，用作排序 
     private final Comparator<? super K> comparator; 
     //树的根节点 
     private transient Entry<K,V> root; 
     //树的大小 
     private transient int size = 0; 
     //修改计数器 
     private transient int modCount = 0; 
     //返回map的Entry视图 
     private transient EntrySet entrySet; 
     private transient KeySet<K> navigableKeySet; 
     private transient NavigableMap<K,V> descendingMap; 
     //定义红黑树的颜色 
     private static final boolean RED = false; 
     private static final boolean BLACK = true; 
     }

-

4.TreeMap构造方法

允许用户自定义比较器

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

允许用已有的map构造一个TreeMap

public TreeMap(Map<? extends K, ? extends V> m) { 
        comparator = null; 
        putAll(m); 
    } 
public void putAll(Map<? extends K, ? extends V> map) {
         int mapSize = map.size(); 
         //判断map是否SortedMap，不是则采用AbstractMap的putAll 
         if (size==0 && mapSize!=0 && map instanceof SortedMap){ 
            Comparator<?> c = ((SortedMap<?,?>)map).comparator(); 
            //同为null或者不为null，类型相同，则进入有序map的构造 
            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); 
}

让我们来看一下buildFrmoSorted函数

/** 
* size: map里键值对的数量 
* it: 传入的map的entries迭代器 
* str: 如果不为空，则从流里读取key-value 
* defaultVal：见名知意，不为空，则value都用这个值 
*/
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); 
                }

computeRedLevel(size)

private static int computeRedLevel(int sz) {
         int level = 0; 
         for (int m = sz - 1; m >= 0; m = m / 2 - 1) 
                level++; 
         return level; 
    }

这个函数是干什么的呢？
它的作用是用来计算完全二叉树的层数。什么意思呢，先来看一下下面的图：

把根结点索引看为0，那么高度为2的树的最后一个节点的索引为2，类推高度为3的最后一个节点为6，满足m = (m + 1) * 2。那么计算这个高度有什么好处呢，如上图，如果一个树有9个节点，那么我们构造红黑树的时候，只要把前面3层的结点都设置为黑色，第四层的节点设置为红色，则构造完的树，就是红黑树，满足前面提到的红黑树的5个条件。而实现的关键就是找到要构造树的完全二叉树的层数。值得注意的是完全二叉树的层是从0开始计算的。

现在看这个函数应该很容易懂

    /** level是当前树的层数，从0开始
    * lo是子树第一个元素的索引
    * hi是子树的最后一个元素的索引
    * redLevel是上述红节点所在的层数，从零开始的
    * it: 传入的map的entries迭代器 
    * str: 如果不为空，则从流里读取key-value 
    * defaultVal：见名知意，不为空，则value都用这个值 
    */
    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);

        // 构造key，value
        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);

        //设置红节点
           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;
    }

5.TreeMap的重要方法

get方法

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

    final Entry<K,V> getEntry(Object key) {
        // 如果有比较器，那么通过调用比较器来比较key的方法
        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;
    }

getEntryUsingComparator方法用的是构造器的方法，换汤不换药，就不介绍了。

put方法

    //put方法实现了如果存在key，放回旧值，如果找不到就放进去，返回null
    public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
              //类型检查
            compare(key, key); 

            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 {
                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 {
             //这里也可以看到TreeMap的key在没有构造器的情况下不能为null
            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;
    }

put的逻辑非常清晰，我们知道每次修改树的结构都会破坏红黑树的性质。
fixAfterInsertion对插入结点后的红黑树进行修复，维护其平衡，我们接着来看看它是如何实现的（在继续看之前，建议大家了解一下左旋转和右旋转的操作）。

这里就稍微解释一下：

第一步：找到插入的位置。

第二步：将插入的节点着色为”红色”。
为什么着色成红色，而不是黑色呢？为什么呢？在回答之前，我们需要重新温习一下红黑树的特性：

• (1) 每个节点或者是黑色，或者是红色。
• (2) 根节点是黑色。
• (3) 每个叶子节点是黑色。 [注意：这里叶子节点，是指为空的叶子节点！]
• (4) 如果一个节点是红色的，则它的子节点必须是黑色的。

• (5) 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

  将插入的节点着色为红色，不会违背”特性(5)”！少违背一条特性，就意味着我们需要处理的情况越少。接下来，就要努力的让这棵树满足其它性质即可；满足了的话，它就又是一颗红黑树了。

第三步: 通过一系列的旋转或着色等操作，使之重新成为一颗红黑树。

只有对于”特性(4)”，是有可能违背的！
那接下来，想办法使之”满足特性(4)”，就可以将树重新构造成红黑树了。

看代码的时候，建议一边对着这个博客去看：
红黑树的添加

    private void fixAfterInsertion(Entry<K,V> x) {
        //将插入点着色为红色
        x.color = RED;

         //父亲是红节点时，分三种情况解决的
        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) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));

                 //叔叔是黑色，且当前节点是右孩子
                 //将“父节点”作为“新的当前节点”，以“新的当前节点”为支点进行左旋。
                } else {
                    if (x == rightOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateLeft(x);
                    }

                    //发生了第二种情况一般就有第三种情况的发生，
                    //即叔叔节点是黑色，且当前节点是左孩子
                    //则将“父节点”设为“黑色”，将“祖父节点”设为“红色”，以“祖父节点”为支点进行右旋。
                    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;
    }

至于左旋转和右旋转就不拿出来分析了。有点抽象，不好说。

remove方法

public V remove(Object key) { 
        //获取Entry Entry<K,V> p = getEntry(key); 
        if (p == null) return null; V oldValue = p.value; 
        //删除的关键方法 deleteEntry(p); return oldValue; 
    }

在看deleteEntry之前，我们先来看一下successor方法，为其做准备，
这个方法的作用是根据key找到比一个最小的比t(参数)的key大的Entry。

 static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
        if (t == null)
            return null;
        //从t的右子树中找到最小的
        else if (t.right != null) {
            Entry<K,V> p = t.right;
            while (p.left != null)
                p = p.left;
            return p;
            //当右子树为空时，向上找到第一个左父节点
        } else {
            Entry<K,V> p = t.parent;
            Entry<K,V> ch = t;
            while (p != null && ch == p.right) {
                ch = p;
                p = p.parent;
            }
            return p;
        }
    }

删除的思路是两步，删了然后再修复

  private void deleteEntry(Entry<K,V> p) {
        modCount++;
        size--;

         //p的左右子树都不为空，找到右子树中最小的结点，将key、value赋给p，然后p指向后继结点
         //转化成了下面的情况
        if (p.left != null && p.right != null) {
            Entry<K,V> s = successor(p);
            p.key = s.key;
            p.value = s.value;
            p = s;
        } 

        // 存在一个孩子或者没有孩子的情况
        //直接删除就好了
        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;
            }
        }
    }

fixAfterDeletion的源码，还是和上面添加操作一样，对着红黑树的原理看会比较简单：
下面就不做解释了

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) {
                    setColor(sib, BLACK);
                    setColor(parentOf(x), RED);
                    rotateLeft(parentOf(x));
                    sib = rightOf(parentOf(x));
                }

                if (colorOf(leftOf(sib))  == BLACK &&
                    colorOf(rightOf(sib)) == BLACK) {
                    setColor(sib, RED);
                    x = parentOf(x);
                } else {
                    if (colorOf(rightOf(sib)) == BLACK) {
                        setColor(leftOf(sib), BLACK);
                        setColor(sib, RED);
                        rotateRight(sib);
                        sib = rightOf(parentOf(x));
                    }
                    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);
    }

总结： TreeMap这一章对于数据结构的要求比较高，因为用了红黑树，比HashMap的实现多了排序的功能，所以他的操作都是十分复杂的，希望大家能够静下心来，多去了解一下为什么要这么做。