TreeMap

需要先了解红黑树，这是之前分析红黑树的文章。
之前在分析红黑树时，我认为红黑树=二叉查找树+红黑平衡，关于二叉查找树这是递归版本的，而在TreeMap中实现的是非递归版本的。
TreeMap的继承关系：

关于SortedMap，NavigableMap

 

get与put操作都很简单，注意TreeMap不允许键为null，对TreeMap来说comparator不为null则利用该比较器进行key键比较，否则利用key键本身这要求键必须实现Comparable接口，实现自己的compareTo逻辑，所以对于TreeMap作为键的对象要么你提供一个comparator比较器，要么这个对象是Comparable。
对于HashMap，它允许一个键为null的节点，因为HashMap比较的是hash值（null的hash值在HashMap中为0），但作为键的对象最好重写equals方法，当然重写equals就应该重写hashcode方法。
1.8后Comparator接口更加强健，配合lambda，代码更加简洁易懂。

remove

    public V remove(Object key) {
        Entry<K,V> p = getEntry(key);
        if (p == null)
            return null;

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

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

若当前节点的左右皆不为空，则找到其右子节点的最左节点与其进行键值的替换，问题就转化为删除这个最小节点。所以最后要删除的节点存在两种情况：1，没有子节点。2，只有一个子孩子非空。对于这两种情况的处理不同。情况1，若它颜色为黑则先进行红黑调整fixAfterDeletion，后在根据情况进行删除。该方法介绍在红黑树。情况2，先删除该节点，若其为黑，对其左/右子树进行红黑平衡。

successor

    static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
        if (t == null)
            return null;
        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;
        }
    }

返回的是最接近的大于t的节点，就是大于t的节点中最小的那个节点。
两种情况，右子孩子非空则返回其最左节点；为空则沿着右连接往上直到拐点。

图中t, E是父子关系。
按照上面的代码返回的就是的就是P节点，对于P若它有右子树那么也只可能有一个节点，且为红，这是由红黑树性质决定的。P是大于t节点中是最接近于t的，你可以在该图中任意延申扩展，在根据大小关系推，便可得到证明。

图中P,M是父子关系。
P节点是大于 t 中最小的节点，也就是最接近的节点。

 

predecessor(t)
该方法返回的是小于 t 的节点中最大的节点，也就是最接近的节点。

    static <K,V> Entry<K,V> predecessor(Entry<K,V> t) {
        if (t == null)
            return null;
        else if (t.left != null) {
            Entry<K,V> p = t.left;
            while (p.right != null)
                p = p.right;
            return p;
        } else {
            Entry<K,V> p = t.parent;
            Entry<K,V> ch = t;
            while (p != null && ch == p.left) {
                ch = p;
                p = p.parent;
            }
            return p;
        }
    }

像上面一样画出图就能够看出。

之前在SortedMap，NavigableMap中介绍了很多返回各种视图的方法，现在来看看在TreeMap中的实现。

lowerEntry<