集合之TreeMap（含JDK1.8源码分析）
一、前言
前面所说的hashMap和linkedHashMap都不具备统计的功能，或者说它们的统计性能的时间复杂度都不是很好，要想对两者进行统计，需要遍历所有的entry，时间复杂度比较高，此时，我们就需要使用treeMap。
treeMap的key按照自然顺序进行排序或根据创建时提供的comparator接口进行排序，TreeMap为增、删、改、查这些操作提供了log(N)的时间开销，从存储角度而言，这比HashMap与LinkedHashMap的O(1)时间复杂度要差些；但是在统计性能上，TreeMap同样可以保证log(N)的时间开销，这又比HashMap与LinkedHashMap的O(N)时间复杂度好不少。
因此，如果只需要存储功能，使用hashMap或linkedHashMap是一种更好的选择；如果还需要保证统计功能或是对key按照一定的规则进行排序，那么使用treeMap是一种更好的选择。
四个关注点在treeMap上的答案
二、treeMap的数据结构
treeMap底层使用的数据结构是红黑树，下图为典型的红黑树结构，效率很高。
用来存储key-value的是treeMap中的Entry类，除了key-value属性，还有该节点的左节点left，右节点right，父节点parent。
三、treeMap源码分析-属性及构造函数
3.1 类的继承关系
public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable
说明：继承了抽象类AbstractMap，AbstractMap实现了Map接口，实现了部分方法。实现了NavigableMap,Cloneable,Serializable接口，其中NavigableMap是继承自SortedMap的接口，定义了一系列规范。
3.2 类的属性
/** * The comparator used to maintain order in this tree map, or * null if it uses the natural ordering of its keys. * 比较器，用于维持treeMap中key的顺序，为null时，使用的是key的自然顺序 * @serial */ private final Comparator<? super K> comparator; //树的根节点 private transient Entry<K,V> root; /** * The number of entries in the tree 树中节点的数量 */ private transient int size = 0; /** * The number of structural modifications to the tree. 对树进行结构性修改的次数 */ private transient int modCount = 0;
3.3 类的构造函数
1、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; }
说明：定义一个新的，空的treeMap，排序规则是key的自然顺序，所有要存储的元素的key必须实现Comparable接口，而且，这些key要可以互相比较，否则会抛ClassCastException，即类型转换异常。
举例：正常情况下，key实现了Comparable接口
public class Test { public static void main(String[] args) { TreeMap<String, String> treeMap = new TreeMap<>(); treeMap.put("a","aaa"); treeMap.put("d","ddd"); treeMap.put("b","bbb"); treeMap.put("c","ccc"); Set<Map.Entry<String, String>> entries = treeMap.entrySet(); for(Map.Entry<String, String> entry : entries) { System.out.println(entry.getKey() + "========" + entry.getValue()); } } }
结果：
a========aaa b========bbb c========ccc d========ddd
说明：可以看到，treeMap中已经根据key的自然顺序进行排序了，key所属类型String类实现了Comparable接口
public final class String implements java.io.Serializable, Comparable<String>, CharSequence
key所属String类下的比较规则：
/** * Compares two strings lexicographically. * The comparison is based on the Unicode value of each character in * the strings. The character sequence represented by this * {@code String} object is compared lexicographically to the * character sequence represented by the argument string. The result is * a negative integer if this {@code String} object * lexicographically precedes the argument string. The result is a * positive integer if this {@code String} object lexicographically * follows the argument string. The result is zero if the strings * are equal; {@code compareTo} returns {@code 0} exactly when * the {@link #equals(Object)} method would return {@code true}. * <p> * This is the definition of lexicographic ordering. If two strings are * different, then either they have different characters at some index * that is a valid index for both strings, or their lengths are different, * or both. If they have different characters at one or more index * positions, let <i>k</i> be the smallest such index; then the string * whose character at position <i>k</i> has the smaller value, as * determined by using the < operator, lexicographically precedes the * other string. In this case, {@code compareTo} returns the * difference of the two character values at position {@code k} in * the two string -- that is, the value: * <blockquote><pre> * this.charAt(k)-anotherString.charAt(k) * </pre></blockquote> * If there is no index position at which they differ, then the shorter * string lexicographically precedes the longer string. In this case, * {@code compareTo} returns the difference of the lengths of the * strings -- that is, the value: * <blockquote><pre> * this.length()-anotherString.length() * </pre></blockquote> * * @param anotherString the {@code String} to be compared. * @return the value {@code 0} if the argument string is equal to * this string; a value less than {@code 0} if this string * is lexicographically less than the string argument; and a * value greater than {@code 0} if this string is * lexicographically greater than the string argument. */ public int compareTo(String anotherString) { int len1 = value.length; int len2 = anotherString.value.length; int lim = Math.min(len1, len2); char v1[] = value; char v2[] = anotherString.value; int k = 0; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; if (c1 != c2) { return c1 - c2; } k++; } return len1 - len2; }
第二种情况：定义一个Student类当做treeMap的key，Student类并未实现Comparable接口
public class Student{ private String name; private String age; public Student() { } public Student(String name, String age) { this.name = name; this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age='" + age + '\'' + '}'; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } }
测试一下：
public class Test { public static void main(String[] args) { TreeMap<Student, String> treeMap = new TreeMap<>(); Student student1 = new Student("zs", "10"); Student student2 = new Student("ls", "12"); Student student3 = new Student("ww", "11"); Student student4 = new Student("zl", "15"); treeMap.put(student1,"beijing"); treeMap.put(student2,"shenzhen"); treeMap.put(student3,"hangzhou"); treeMap.put(student4,"guangzhou"); Set<Map.Entry<Student, String>> entries = treeMap.entrySet(); for(Map.Entry<Student, String> entry : entries) { System.out.println(entry.getKey() + "==========" + entry.getValue()); } } }
结果：
Exception in thread "main" java.lang.ClassCastException: com.dajia.test.Student cannot be cast to java.lang.Comparable at java.util.TreeMap.compare(TreeMap.java:1294) at java.util.TreeMap.put(TreeMap.java:538) at com.dajia.test.Test.main(Test.java:23)
说明：可以看到，当key未实现Comparable接口时，在put元素的时候就会报错。
当Student类实现Comparable接口时：比较规则是按照age的大小进行比较
public class Student implements Comparable<Student>{ private String name; private String age; public Student() { } public Student(String name, String age) { this.name = name; this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age='" + age + '\'' + '}'; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } @Override public int compareTo(Student o) { return this.age.compareTo(o.age); } }
相同的测试代码测试一下，结果：按照key（student）的排序规则进行了排序
Student{name='zs', age='10'}==========beijing
Student{name='ww', age='11'}==========hangzhou
Student{name='ls', age='12'}==========shenzhen
Student{name='zl', age='15'}==========guangzhou
2、TreeMap(Comparator<? super K> comparator)型
/** * 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; }
说明：定义一个新的，空的treeMap，参数是自定义的比较器，排序规则是该比较器的比较规则，这些key要可以互相比较，否则会抛ClassCastException，即类型转换异常。
举例：自定义一个比较器StudentComparator，比较student下的age大小
public class StudentComparator implements Comparator<Student>{ @Override public int compare(Student o1, Student o2) { return o1.getAge().compareTo(o2.getAge()); } }
测试一下：
public class Test { public static void main(String[] args) { StudentComparator studentComparator = new StudentComparator(); TreeMap<Student, String> treeMap = new TreeMap<>(studentComparator); Student student1 = new Student("zs", "10"); Student student2 = new Student("ls", "12"); Student student3 = new Student("ww", "11"); Student student4 = new Student("zl", "15"); treeMap.put(student1,"beijing"); treeMap.put(student2,"shenzhen"); treeMap.put(student3,"hangzhou"); treeMap.put(student4,"guangzhou"); Set<Map.Entry<Student, String>> entries = treeMap.entrySet(); for(Map.Entry<Student, String> entry : entries) { System.out.println(entry.getKey() + "==========" + entry.getValue()); } } }
结果：
Student{name='zs', age='10'}==========beijing
Student{name='ww', age='11'}==========hangzhou
Student{name='ls', age='12'}==========shenzhen
Student{name='zl', age='15'}==========guangzhou
3、TreeMap(Map<? extends K, ? extends V> m)型
/** * 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); }
说明：定义一个新的treeMap，根据key的自然排序将参数中m的元素存储到treeMap中。
4、TreeMap(SortedMap<K, ? extends V> m)型
/** * Constructs a new tree map containing the same mappings and * using the same ordering as the specified sorted map. This * method runs in linear time. * * @param m the sorted map whose mappings are to be placed in this map, * and whose comparator is to be used to sort this map * @throws NullPointerException if the specified map is null */ 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) { } }
说明：定义一个新的treeMap，根据sortedMap中比较器的排序规则将参数中m的元素存储到treeMap中。
四、treeMap源码分析-核心函数
4.1 增：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 */ public V put(K key, V value) { //将根节点赋值给t Entry<K,V> t = root; if (t == null) { //根节点为null，添加的是第一个元素，先check key的type 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;//定义put进来的元素的父节点 // split comparator and comparable paths Comparator<? super K> cpr = comparator; if (cpr != null) { do { parent = t;//获取要存储元素的parent节点 //从root开始，比较两者key的大小 cmp = cpr.compare(key, t.key); if (cmp < 0) //小于已存在节点的key，将t.left赋值给t，以便再次进行比较 t = t.left; else if (cmp > 0) //大于已存在节点的key，将t.right赋值给t,以便再次进行比较 t = t.right; else //为0，表示两者相等，用value替换原value值，并返回原value return t.setValue(value); } while (t != null);//t != null，接着进行比较 } else { //The comparator used to maintain order in this tree map, or null if it uses the natural ordering of its keys. if (key == null) throw new NullPointerException(); @SuppressWarnings("unchecked")//获取key的compareTo方法 Comparable<? super K> k = (Comparable<? super K>) key; do { parent = t;//获取要存储元素的parent节点 //从root开始，比较两者key的大小 cmp = k.compareTo(t.key); if (cmp < 0) //小于已存在节点的key，将t.left赋值给t，以便再次进行比较 t = t.left; else if (cmp > 0) //大于已存在节点的key，将t.right赋值给t,以便再次进行比较 t = t.right; else //为0，表示两者相等，用value替换原value值，并返回原value return t.setValue(value); } while (t != null);//t != null，接着进行比较 } //构建要存储的新元素 Entry<K,V> e = new Entry<>(key, value, parent); if (cmp < 0)//小于0，位于parent的左边 parent.left = e; else//大于0，位于parent元素的右边 parent.right = e; //插入后进行修正 fixAfterInsertion(e); size++; modCount++; return null; }
说明：插入一个元素时，若用户自定义一个比较器，则会按照用户自定义比较器中的排序规则确定元素的插入位置，否则，将会使用key自身实现的比较器确定插入位置。该方法主要是通过key的比较寻找插入节点的parent节点，并将parent节点与插入节点联系起来。
4.2 删：remove和removeNode函数----删除元素
/** * Removes the mapping for this key from this TreeMap if present. * * @param key key for which mapping should be removed * @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 */ 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获取要删除的节点
/** * 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 */ 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; //比较器为null，通过key的循环比较获取节点 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; }
再通过deleteEntry将该节点进行删除，这个方法没看懂，先放着 o(╥﹏╥)o
/** * Delete node p, and then rebalance the tree. */ 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; } } }
4.3 改：put函数----修改元素
参见4.1中的put函数，可以将相同key的value覆盖。
4.4 查：get和getEntry方法----查找元素
/** * 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 */ public V get(Object key) { Entry<K,V> p = getEntry(key); return (p==null ? null : p.value); }
getEntry方法参见4.2中的getEntry。
五、总结
由TreeMap我们可以知道其底层的数据结构为红黑树，并且可以使用用户自定义的比较器来实现比较逻辑。红黑树还是难了点，插入之后的旋转看着还是头晕，以后有时间在好好研究。
参考资料：
https://www.cnblogs.com/leesf456/p/5255370.html
https://www.cnblogs.com/xrq730/p/6867924.html
