TreeMap源代码深入剖析

第1部分 TreeMap介绍

A Red-Black tree based NavigableMap implementation. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used.

This implementation provides guaranteed log(n) time cost for the containsKey, get, put and remove operations. Algorithms are adaptations of those in Cormen, Leiserson, and Rivest's Introduction to Algorithms.

Note that the ordering maintained by a tree map, like any sorted map, and whether or not an explicit comparator is provided, must be consistent with equals if this sorted map is to correctly implement the Map interface. (See Comparable or Comparator for a precise definition of consistent with equals.) This is so because the Map interface is defined in terms of the equals operation, but a sorted map performs all key comparisons using its compareTo (or compare) method, so two keys that are deemed equal by this method are, from the standpoint of the sorted map, equal. The behavior of a sorted map is well-defined even if its ordering is inconsistent with equals; it just fails to obey the general contract of the Map interface.

Note that this implementation is not synchronized. If multiple threads access a map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally. (A structural modification is any operation that adds or deletes one or more mappings; merely changing the value associated with an existing key is not a structural modification.) This is typically accomplished by synchronizing on some object that naturally encapsulates the map. If no such object exists, the map should be "wrapped" using the Collections.synchronizedSortedMap method. This is best done at creation time, to prevent accidental unsynchronized access to the map:

   SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));

The iterators returned by the iterator method of the collections returned by all of this class's "collection view methods" are fail-fast: if the map is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

All Map.Entry pairs returned by methods in this class and its views represent snapshots of mappings at the time they were produced. They do not support the Entry.setValue method. (Note however that it is possible to change mappings in the associated map using put.) 

之前已经学习过HashMap和LinkedHashMap了，HashMap不保证数据有序，LinkedHashMap保证数据可以保持插入顺序，而如果我们希望Map可以保持key的大小顺序的时候，我们就需要利用TreeMap了。TreeMap的排序是基于对key的排序。

public class Test {
    public static void main(String[] args) {
        Map<Integer, String> treeMap = new TreeMap<Integer, String>();
        treeMap.put(1, "语文");
        treeMap.put(3, "英语");
        treeMap.put(2, "数学");
        treeMap.put(4, "政治");
        treeMap.put(5, "历史");
        treeMap.put(6, "地理");
        treeMap.put(7, "生物");
        treeMap.put(8, "化学");
        for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

1 : 语文
2 : 数学
3 : 英语
4 : 政治
5 : 历史
6 : 地理
7 : 生物
8 : 化学

结果是有序的

其大致的结构如下所示：

aaarticlea/png;base64,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" alt="" />

put的顺序不同，构建的树的结构也是不同的！

使用红黑树的好处是能够使得树具有不错的平衡性，这样操作的速度就可以达到log(n)的水平了。

TreeMap的构造函数

// 默认构造函数。使用该构造函数,TreeMap中的元素按照key的自然排序进行排列。
TreeMap()

// 创建的TreeMap包含Map
TreeMap(Map<? extends K, ? extends V> copyFrom)

// 指定Tree的比较器
TreeMap(Comparator<? super K> comparator)

// 创建的TreeSet包含copyFrom
TreeMap(SortedMap<K, ? extends V> copyFrom)

第2部分 TreeMap数据结构

TreeMap的继承关系

java.lang.Object
   ↳     java.util.AbstractMap<K, V>
         ↳     java.util.TreeMap<K, V>

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

TreeMap与Map关系如下图：

从图中可以看出：
(01) TreeMap实现继承于AbstractMap，并且实现了NavigableMap接口。
(02) TreeMap的本质是R-B Tree(红黑树)，它包含几个重要的成员变量： root, size, comparator。
　　root

是红黑数的根节点。它是Entry类型，Entry是红黑数的节点，它包含了红黑数的6个基本组成成分：key(键)、value(值)、left(左孩
子)、right(右孩子)、parent(父节点)、color(颜色)。Entry节点根据key进行排序，Entry节点包含的内容为value。

　　红黑数排序时，根据Entry中的key进行排序；Entry中的key比较大小是根据比较器comparator来进行判断的。
　　size是红黑数中节点的个数。

第3部分 TreeMap API源码解析

第3.1部分 TreeMap的红黑树相关内容
TreeMap中于红黑树相关的主要函数有:
1 数据结构
1.1 红黑树的节点颜色--红色

private static final boolean RED = false;

1.2 红黑树的节点颜色--黑色

private static final boolean BLACK = true;

1.3 “红黑树的节点”对应的类。

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.
     */
    Entry(K key, V value, Entry<K,V> parent) {
        this.key = key;
        this.value = value;
        this.parent = parent;
    }

    /**
     * Returns the key.
     *
     * @return the key
     */
    public K getKey() {
        return key;
    }

    /**
     * Returns the value associated with the key.
     *
     * @return the value associated with the key
     */
    public V getValue() {
        return value;
    }

    /**
     * Replaces the value currently associated with the key with the given
     * value.
     *
     * @return the value associated with the key before this method was
     *         called
     */
    public V setValue(V value) {
        V oldValue = this.value;
        this.value = value;
        return oldValue;
    }

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

Entry包含了6个部分内容：key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)
Entry节点根据key进行排序，Entry节点包含的内容为value。

2 相关操作
2.1 左旋

private void rotateLeft(Entry<K,V> p) { ... }

2.2 右旋

private void rotateRight(Entry<K,V> p) { ... }

2.3 插入操作

public V put(K key, V value) { ... }

2.4 插入修正操作
红黑树执行插入操作之后，要执行“插入修正操作”。
目的是：保红黑树在进行插入节点之后，仍然是一颗红黑树

private void fixAfterInsertion(Entry<K,V> x) { ... }

2.5 删除操作

private void deleteEntry(Entry<K,V> p) { ... }

2.6 删除修正操作
红黑树执行删除之后，要执行“删除修正操作”。
目的是保证：红黑树删除节点之后，仍然是一颗红黑树

private void fixAfterDeletion(Entry<K,V> x) { ... }

第3.2部分 TreeMap的构造函数
1 默认构造函数
使用默认构造函数构造TreeMap时，使用java的默认的比较器比较Key的大小，从而对TreeMap进行排序。

/**
 * Constructs a new, empty tree map, using the natural ordering of its
 * keys.  All keys inserted into the map must implement the {@link
 * Comparable} interface.  Furthermore, all such keys must be
 * <em>mutually comparable</em>: {@code k1.compareTo(k2)} must not throw
 * a {@code ClassCastException} for any keys {@code k1} and
 * {@code k2} in the map.  If the user attempts to put a key into the
 * map that violates this constraint (for example, the user attempts to
 * put a string key into a map whose keys are integers), the
 * {@code put(Object key, Object value)} call will throw a
 * {@code ClassCastException}.
 */
public TreeMap() {
    comparator = null;
}

2 带比较器的构造函数

/**
 * Constructs a new, empty tree map, ordered according to the given
 * comparator.  All keys inserted into the map must be <em>mutually
 * comparable</em> by the given comparator: {@code comparator.compare(k1,
 * k2)} must not throw a {@code ClassCastException} for any keys
 * {@code k1} and {@code k2} in the map.  If the user attempts to put
 * a key into the map that violates this constraint, the {@code put(Object
 * key, Object value)} call will throw a
 * {@code ClassCastException}.
 *
 * @param comparator the comparator that will be used to order this map.
 *        If {@code null}, the {@linkplain Comparable natural
 *        ordering} of the keys will be used.
 */
public TreeMap(Comparator<? super K> comparator) {
    this.comparator = comparator;
}

3 带Map的构造函数，Map会成为TreeMap的子集

/**
 * Constructs a new tree map containing the same mappings as the given
 * map, ordered according to the <em>natural ordering</em> of its keys.
 * All keys inserted into the new map must implement the {@link
 * Comparable} interface.  Furthermore, all such keys must be
 * <em>mutually comparable</em>: {@code k1.compareTo(k2)} must not throw
 * a {@code ClassCastException} for any keys {@code k1} and
 * {@code k2} in the map.  This method runs in n*log(n) time.
 *
 * @param  m the map whose mappings are to be placed in this map
 * @throws ClassCastException if the keys in m are not {@link Comparable},
 *         or are not mutually comparable
 * @throws NullPointerException if the specified map is null
 */
public TreeMap(Map<? extends K, ? extends V> m) {
    comparator = null;
    putAll(m);
}

该构造函数会调用putAll()将m中的所有元素添加到TreeMap中。putAll()源码如下：
从中，我们可以看出putAll()就是将m中的key-value逐个的添加到TreeMap中。

public void putAll(Map<? extends K, ? extends V> m) {
    for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
        put(e.getKey(), e.getValue());
}

4 带SortedMap的构造函数，SortedMap会成为TreeMap的子集

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) {
    }
}

该构造函数不同于上一个构造函数，在上一个构造函数中传入的参数是Map，Map不是有序的，所以要逐个添加。
而该构造函数的参数是SortedMap是一个有序的Map，我们通过buildFromSorted()来创建对应的Map。
buildFromSorted涉及到的代码如下：

// 根据已经一个排好序的map创建一个TreeMap
    // 将map中的元素逐个添加到TreeMap中，并返回map的中间元素作为根节点。
    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) / 2;

        Entry<K,V> left  = null;
        // 若lo小于mid，则递归调用获取(middel的)左孩子。
        if (lo < mid)
            left = buildFromSorted(level+1, lo, mid - 1, redLevel,
                   it, str, defaultVal);

        // 获取middle节点对应的key和value
        K key;
        V value;
        if (it != null) {
            if (defaultVal==null) {
                Map.Entry<K,V> entry = (Map.Entry<K,V>)it.next();
                key = entry.getKey();
                value = entry.getValue();
            } else {
                key = (K)it.next();
                value = defaultVal;
            }
        } else { // use stream
            key = (K) str.readObject();
            value = (defaultVal != null ? defaultVal : (V) str.readObject());
        }

        // 创建middle节点
        Entry<K,V> middle =  new Entry<K,V>(key, value, null);

        // 若当前节点的深度=红色节点的深度，则将节点着色为红色。
        if (level == redLevel)
            middle.color = RED;

        // 设置middle为left的父亲，left为middle的左孩子
        if (left != null) {
            middle.left = left;
            left.parent = middle;
        }

        if (mid < hi) {
            // 递归调用获取(middel的)右孩子。
            Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel,
                           it, str, defaultVal);
            // 设置middle为left的父亲，left为middle的左孩子
            middle.right = right;
            right.parent = middle;
        }

        return middle;
    }

要理解buildFromSorted，重点说明以下几点：
第一，buildFromSorted是通过递归将SortedMap中的元素逐个关联。
第二，buildFromSorted返回middle节点(中间节点)作为root。
第三，buildFromSorted添加到红黑树中时，只将level == redLevel的节点设为红色。第level级节点，实际上是buildFromSorted转换成红黑树后的最底端(假设根节点在最上方)的节点；只将红黑树最底端的阶段着色为红色，其余都是黑色。

 第3.3部分 TreeMap的put方法

/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 *
 * @return the previous value associated with {@code key}, or
 *         {@code null} if there was no mapping for {@code key}.
 *         (A {@code null} return can also indicate that the map
 *         previously associated {@code null} with {@code key}.)
 * @throws ClassCastException if the specified key cannot be compared
 *         with the keys currently in the map
 * @throws NullPointerException if the specified key is null
 *         and this map uses natural ordering, or its comparator
 *         does not permit null keys
 */
// 将"key, value"添加到TreeMap中
// 理解TreeMap的前提是掌握"红黑树"。
// 若理解"红黑树中添加节点"的算法，则很容易理解put。
public V put(K key, V value) {
    Entry<K,V> t = root;
    // 若红黑树为空，则插入根节点
    if (t == null) {
        compare(key, key); // type check
        root = new Entry<K,V>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }
    int cmp;
    Entry<K,V> parent;
    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator;
    // 在二叉树(红黑树是特殊的二叉树)中，找到(key, value)的插入位置。
    // 红黑树是以key来进行排序的，所以这里以key来进行查找。
    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();
        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);
    }
    // 新建红黑树的节点(e)
    Entry<K,V> e = new Entry<K,V>(key, value, parent);
    if (cmp < 0)
        parent.left = e;
    else
        parent.right = e;
    // 红黑树插入节点后，不再是一颗红黑树；
    // 这里通过fixAfterInsertion的处理，来恢复红黑树的特性。
    fixAfterInsertion(e);
    size++;
    modCount++;
    return null;
}

第3.4部分 TreeMap的get方法

/**
 * Returns the value to which the specified key is mapped,
 * or {@code null} if this map contains no mapping for the key.
 *
 * <p>More formally, if this map contains a mapping from a key
 * {@code k} to a value {@code v} such that {@code key} compares
 * equal to {@code k} according to the map's ordering, then this
 * method returns {@code v}; otherwise it returns {@code null}.
 * (There can be at most one such mapping.)
 *
 * <p>A return value of {@code null} does not <em>necessarily</em>
 * indicate that the map contains no mapping for the key; it's also
 * possible that the map explicitly maps the key to {@code null}.
 * The {@link #containsKey containsKey} operation may be used to
 * distinguish these two cases.
 *
 * @throws ClassCastException if the specified key cannot be compared
 *         with the keys currently in the map
 * @throws NullPointerException if the specified key is null
 *         and this map uses natural ordering, or its comparator
 *         does not permit null keys
 */
// 获取“键(key)”对应的“值(value)”
public V get(Object key) {
    // 获取“键”为key的节点(p)
    Entry<K,V> p = getEntry(key);
    // 若节点(p)为null，返回null；否则，返回节点对应的值
    return (p==null ? null : p.value);
}
/**
 * Returns this map's entry for the given key, or {@code null} if the map
 * does not contain an entry for the key.
 *
 * @return this map's entry for the given key, or {@code null} if the map
 *         does not contain an entry for the key
 * @throws ClassCastException if the specified key cannot be compared
 *         with the keys currently in the map
 * @throws NullPointerException if the specified key is null
 *         and this map uses natural ordering, or its comparator
 *         does not permit null keys
 */
// 获取TreeMap中“键”为key的节点
final Entry<K,V> getEntry(Object key) {
    // 若“比较器”为null，则通过getEntryUsingComparator()获取“键”为key的节点
    if (comparator != null)
        return getEntryUsingComparator(key);
    if (key == null)
        throw new NullPointerException();
    Comparable<? super K> k = (Comparable<? super K>) key;
    // 将p设为根节点
    Entry<K,V> p = root;
    while (p != null) {
        int cmp = k.compareTo(p.key);
        // 若“p的key” < key，则p=“p的左孩子”
        if (cmp < 0)
            p = p.left;
        // 若“p的key” > key，则p=“p的左孩子”
        else if (cmp > 0)
            p = p.right;
        // 若“p的key” = key，则返回节点p
        else
            return p;
    }
    return null;
}

参考资料

TreeMap (Java Platform SE 8)
浅谈算法和数据结构: 九 平衡查找树之红黑树
Java提高篇（二七）——-TreeMap
数据结构之红黑树
wikipedia-红黑树
Red-Black Trees
How TreeMap searches successor for given Entry?