Java集合类-TreeMap分析
TreeMap的特点
TreeMap基于红黑树实现
红黑树是一种弱平衡的二叉树，比AVL树旋转次数少，用弱平衡换取旋转次数
有5个性质：
性质1. 节点是红色或黑色。
性质2. 根节点是黑色。
性质3 每个叶节点（NIL节点，空节点）是黑色的。
性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
特性：最长路径不会长于最短路径2倍
成员变量
private final Comparator<? super K> comparator; // 结点的比较器,用于对树的结点进行排序
树的结点
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; }
构造函数
共有4个构造函数
1、无参构造函数，不指定比较器
public TreeMap() { comparator = null; }
2、无参构造函数，指定比较器
public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; }
3、参数是Map的构造函数
public TreeMap(Map<? extends K, ? extends V> m) { comparator = null; putAll(m); }
下面详细分析下putAll函数
public void putAll(Map<? extends K, ? extends V> map) { int mapSize = map.size(); // 如果TreeMap的size为0，且放入的map的size不是0，且是已排序的Map if (size==0 && mapSize!=0 && map instanceof SortedMap) { Comparator<?> c = ((SortedMap<?,?>)map).comparator(); // 放入map的比较器和TreeMap的比较器相同，使用buildFromSorted构建 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; } } // 遍历插入map中的结点到TreeMap super.putAll(map); }
1、如果TreeMap中没有结点，且插入的map是有已排序的map，并且map的比较器和TreeMap的比较器相同，则使用buildFromSorted进行插入
2、否则遍历map中的结点，然后插入到TreeMap
4、参数是SortedMap的构造函数
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，直接使用buildFromSorted进行插入
下面分析下buildFromSorted是如何插入map到TreeMap的
private static int computeRedLevel(int sz) { int level = 0; for (int m = sz - 1; m >= 0; m = m / 2 - 1) level++; return level; }
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 { // lo 树的第一结点的索引 hi 树的最后一个结点的索引 /* * 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-v的值 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()); } // SortedMap中第一个结点作为TreeMap的根结点，默认是黑结点 Entry<K,V> middle = new Entry<>(key, value, null); // color nodes in non-full bottommost level red 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; }
1、构建左子树，然后新建结点，然后构建右子树
2、最终形成的树是在叶子结点以上是一个满二叉树，所以满足红黑树的性质，叶子结点不满足，所以把叶子结点都染成红色
基本方法
增/改 put
public V put(K key, V value) { Entry<K,V> t = root; // 如果没有根结点，也就是树没有结点 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; // 找到插入结点在红黑树中的位置，如果key相等更新改结点value 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(); @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; }
找到插入结点的位置，然后新建结点插入，然后通过fixAfterInsertion调整红黑树的平衡
删 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; }
先通过getEntry找到树结点，然后通过deleteEntry删除该结点
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; 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; }
查 get
public V get(Object key) { Entry<K,V> p = getEntry(key); return (p==null ? null : p.value); }
通过getEntry找到该结点
一些问题
参考
http://blog.csdn.net/ns_code/article/details/36421085
http://blog.csdn.net/jiang_bing/article/details/7537803
