TreeMap
| public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable |
TreeMap这个类，从名字中就可以猜到，应该是一个树结构算法的Map，TreeMap底层的数据结构也是为了维持二叉查找树的平衡性稳定而设计的红黑树。
从上面的源码中可以看到，TreeMap继承了AbstractMap，所以它是一个Map，即K-V集合。
TreepMap实现了NavigableMap接口，而NavigableMap接口是继承于SortedMap接口的，这也就决定了TreeMap和HashMap的不同，HashMap的key是无序的，而TreeMap的key是有序的。
SortedMap接口的注释中可以看到，要求Key必须要实现Comparator或Comparable接口。
另外，TreeMap实现了Serializable接口，说明TreeMap是支持序列化的。
| public interface NavigableMap<K,V> extends SortedMap<K,V> |
总结下来就是TreeMap是基于红黑树实现的键值对Map类，其中键可以按照自然顺序进行排序，或根据存储元素类通过实现Comparator接口实现自定义排序。
TreeMap是非线程安全，即其Iterator的迭代器是Fail-Fast机制的，并且get/put/remove基本操作的时间复杂度都是O(logn)。
注：TreeMap和Hashtable一样，K-V都不能为null，且key不能重复，value可以重复。
排序默认是升序的，数字比较大小，字符串比较首字母，其他类型需要实现Comaparable/Comparator接口，否则排序时会报错。
数据结构：
| static final class Entry<K,V> implements Map.Entry<K,V> { //key值 K key; //value值 V value; //左节点 Entry<K,V> left; //右节点 Entry<K,V> right; //父节点 Entry<K,V> parent; //节点颜色 boolean color = BLACK;
/** * 构造方法，节点颜色默认为黑色 * @param key key值 * @param value value值 * @param parent parent初始化 */ Entry(K key, V value, Entry<K,V> parent) { this.key = key; this.value = value; this.parent = parent; }
/** * 获取key */ public K getKey() { return key; }
/** * 获取value */ public V getValue() { return value; }
/** * 替换节点的值，返回旧值 */ public V setValue(V value) { V oldValue = this.value; this.value = value; return oldValue; }
/** * 重写equals方法 */ public boolean equals(Object o) { //判断类型 if (!(o instanceof Map.Entry)) return false;
//墙砖 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
//两个节点的key相等，value相等，这两个节点才相等 return valEquals(key,e.getKey()) && valEquals(value,e.getValue()); }
/** * 重写hashCode方法 */ public int hashCode() { int keyHash = (key==null ? 0 : key.hashCode()); int valueHash = (value==null ? 0 : value.hashCode());
//key和value hash值异或运算，相同为0，不同为1 return keyHash ^ valueHash; }
/** * 重写toString方法 */ public String toString() { return key + "=" + value; } } |
基本属性：
| /** * 比较器，是自然排序还是定制排序，使用final修饰，表明一旦赋值便不允许改变 */ private final Comparator<? super K> comparator;
/** * 红黑树的根节点 */ private transient Entry<K,V> root;
/** * TreeMap中存放的键值对的数量 */ private transient int size = 0;
/** * 修改的次数 */ private transient int modCount = 0; |
构造器：
| /** * 1、Comaprator用键的顺序做比较 */ public TreeMap() { comparator = null; }
/** * 2、按照指定的比较器进行排序 * @param comparator 指定比较器 */ public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; }
/** * 3、将m中的元素转换到TreeMap中国，按照键的顺序进行排序 * @param m void */ public TreeMap(Map<? extends K, ? extends V> m) { comparator = null; putAll(m); } /** * 采用m的比较器进行排序 * @param m void */ 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) { } } |
新增：
| /** * 新增K-V * @param key 要新增的Key * @param value 要新增的Value * @return V key已存在的话，就返回旧的Value，否则返回null */ public V put(K key, V value) { //1、红黑树的根节点 Entry<K,V> t = root;
//2、红黑树是否为空，为空则说明当前节点就是首节点，即根节点 if (t == null) { //2.1、类型可能为空的检查 compare(key, key);
//2.2、构建根节点，根节点的父节点为空 root = new Entry<>(key, value, null);
//2.3、集合元素的数量+1，修改操作+1 size = 1; modCount++; return null; }
//到这就说明根节点不是为空
//3、定义比较结果临时变量cmp int cmp;
//4、定义当前节点的父节点临时变量parent Entry<K,V> parent;
//5、获取比较器 Comparator<? super K> cpr = comparator;
//6、如果定义了比较器，就采用自定义比较器进行比较 if (cpr != null) { do { //6.1、将根节点赋给parent parent = t;
//6.2、比较key与根节点的key大小 cmp = cpr.compare(key, t.key);
//左 < 父 < 右
//6.3、key < 根key = 指向左树 if (cmp < 0) t = t.left; //6.4、key > 根key = 指向右树 else if (cmp > 0) t = t.right; //6.5、相等，则说明这个节点就是当前要找的节点，直接覆盖 else return t.setValue(value);
//6.6、继续循环遍历 } while (t != null); }
//7、没有指定比较器，按照自然顺序排序 else { //7.1、如果key为空，则抛出空指针异常，也说明了TreeMap不支持空key if (key == null) throw new NullPointerException();
//7.2、类型转换 @SuppressWarnings("unchecked") Comparable<? super K> k = (Comparable<? super K>) key;
do { //7.3、将根节点赋给parent parent = t;
//7.4、比较key与根节点的key大小 cmp = k.compareTo(t.key);
//左 < 父 < 右
//7.5、key < 根key = 指向左树 if (cmp < 0) t = t.left; //7.6、key > 根key = 指向右树 else if (cmp > 0) t = t.right; //7.7、相等，则说明这个节点就是当前要找的节点，直接覆盖 else return t.setValue(value);
//7.8、继续循环遍历 } while (t != null); }
//运行到这就说明了没有已存在的key
//9、创建新节点，并指定父节点 Entry<K,V> e = new Entry<>(key, value, parent);
//根据比较节点决定新节点在父节点的左还是右 //10、key < 父key = 指向左树 if (cmp < 0) parent.left = e; //11、key > 父key = 指向右树 else parent.right = e;
//12、新插入节点后，重新平衡红黑树 fixAfterInsertion(e);
//13、集合元素的数量+1，修改操作+1 size++; modCount++; return null; } /** * 比较方法 * @param k1 * @param k2 */ final int compare(Object k1, Object k2) { //如果comparator=null //采用comparable.compareTo进行比较 //否则采用指定比较器比较大小 return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2) : comparator.compare((K)k1, (K)k2); }
/** * 新插入节点，重新平衡红黑树 * @author suzhiwei * @param x void */ private void fixAfterInsertion(Entry<K,V> x) { //1、新插入的节点，默认元素颜色为红色 x.color = RED;
//2、进入循环 //情况1：新节点x是树的根节点，没有父节点，不需要任何操作，即不进入循环 //情况2：新节点x的父节点的颜色是黑色，也不需要任何操作，即不进入循环 while (x != null && x != root && x.parent.color == RED) {
//符合循环条件 //情况3：新节点x的父节点颜色是红色，
//2.1、判断x的节点的父节点的位置，是否是位于左树 if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
//2.1.1、已经判断出x节点的父节点是左树，获取x节点的父节点的兄弟节点，右节点 Entry<K,V> y = rightOf(parentOf(parentOf(x)));
//2.1.2、判断是否x节点的父节点的右节点为红色 if (colorOf(y) == RED) { //2.1.2.1、x节点设置为黑色 setColor(parentOf(x), BLACK); //2.1.2.2、y节点的颜色设置为黑色 setColor(y, BLACK); //2.1.2.3、x.parent.parent设置为红色 setColor(parentOf(parentOf(x)), RED); //2.1.2.4、x == x.parent.parent，进行遍历 x = parentOf(parentOf(x));
//2.1.3、x节点的父节点的右节点为黑色，x的父节点的右节点是黑色或者缺少的 } else { //2.1.3.1、判断x节点是否为父节点的右节点 if (x == rightOf(parentOf(x))) { //2.1.3.1.1、x == 父节点 x = parentOf(x); //2.1.3.1.2、左旋转操作 rotateLeft(x); } //2.1.3.2、x节点是其父的左孩子 //将x.parent和x.parent.parent的颜色互换 setColor(parentOf(x), BLACK); setColor(parentOf(parentOf(x)), RED); //2.1.3.3、进行右旋转 rotateRight(parentOf(parentOf(x))); }
//2.1.3、x的父节点位于右树 } else { //2.1.3.1、y是x节点的x.parent.parent的左节点，取出父节点的左节点 Entry<K,V> y = leftOf(parentOf(parentOf(x)));
//2.1.3.2、判断父节点的左节点颜色是否是红色 if (colorOf(y) == RED) { //2.1.3.2.1、父节点设置为红色 setColor(parentOf(x), BLACK); //2.1.3.2.2、父节点的左节点设置为黑色 setColor(y, BLACK); //2.1.3.2.3、x.parent.parent节点设置为红色 setColor(parentOf(parentOf(x)), RED); //2.1.3.2.4、将x.parent.parent作为新插入的节点，遍历调整 x = parentOf(parentOf(x));
//2.1.3.3、父节点的左节点颜色是黑色 } else { //2.1.3.3.1、x是x.parent的左节点 if (x == leftOf(parentOf(x))) { //2.1.3.3.1.1、x == 父节点 x = parentOf(x); //2.1.3.3.1.2、右旋转操作 rotateRight(x); } //2.1.3.3.2、设置父节点为黑色 setColor(parentOf(x), BLACK); //2.1.3.3.3、设置x.parent.parent为红色 setColor(parentOf(parentOf(x)), RED); //2.1.3.3.4、以父节点为旋转点进行左旋操作 rotateLeft(parentOf(parentOf(x))); } } } //3、通过节点位置调整，最终将红色的节点调整到了根节点的位置，根节点设置为黑色。 root.color = BLACK; }
/** * 对红黑树的节点(x)进左旋转 * px px * / / * x y * / \ / \ * lx y x ry * / \ / \ * ly ry lx ly * @param p */ private void rotateLeft(Entry<K,V> p) { //1、当前节点不为空 if (p != null) { //1.1、取得当前节点的右节点 Entry<K,V> r = p.right;
//1.2、当前节点p的右节点指向当前节点p的右节点(r)的左节点 p.right = r.left;
//1.3、如果r的左节点不为空 if (r.left != null) //1.3.1、将p设为r的左节点的父节点 r.left.parent = p;
//1.4、将p的父节点指向为r的父节点 //p的父节点指向为y的父节点 r.parent = p.parent;
//1.5、如果p的父节点是空节点 if (p.parent == null) //1.5.1、将r设置为主节点 root = r; //1.6、如果p是父节点的左节点 else if (p.parent.left == p) //1.6.1、将r设置为p的父节点的左节点 p.parent.left = r; //1.7、如果以上都不符合，则可能是父节点的右节点 else //1.7.1、将p的父节点的右节点设置为r p.parent.right = r;
//1.8、p设置为r的左节点 r.left = p; //1.9、p的父节点设置为r p.parent = r; } }
/** * 对红黑树的节点(y)进行右旋转 * py py * / / * y x * / \ / \ * x ry lx y * / \ / \ * lx rx rx ry * @param p void */ private void rotateRight(Entry<K,V> p) { if (p != null) { //获取当前节点p的左节点 Entry<K,V> l = p.left;
//l的右节点设置为p的左节点 p.left = l.right;
//如果l的右节点不为空 if (l.right != null) //将p设置为l的右节点父节点 l.right.parent = p;
//将p的父节点设置为l的父节点 l.parent = p.parent;
//如果p的父节点为空 if (p.parent == null) //l为根节点 root = l; //如果p的父节点的右节点是p else if (p.parent.right == p) //p的父节点的右节点就是l p.parent.right = l; //如果p的父节点的左节点是p else //将l设置为p的父节点的左节点 p.parent.left = l; //将p设置为l的右节点 l.right = p; //p的父节点设置为l p.parent = l; } } |
查找：
| /** * 根据key获取value * @param key 键 * @return V */ public V get(Object key) { //1、获取value Entry<K,V> p = getEntry(key);
//2、结果是否为空，为空返回null，否则返回value return (p==null ? null : p.value); } /** * 根据key获取到完整的Entry * @param key 键 * @return Entry<K,V> */ final Entry<K,V> getEntry(Object key) { //1、是否有定制比较器 if (comparator != null) //1.1、按照定制比较器的排序方式获取 //循环遍历树，寻找和key相等的节点 return getEntryUsingComparator(key);
//2、TreeMap不允许key为空，否则抛空指针异常 if (key == null) throw new NullPointerException();
//3、强制转换 @SuppressWarnings("unchecked") Comparable<? super K> k = (Comparable<? super K>) key;
//4、从根节点开始，作为父节点进行遍历 Entry<K,V> p = root;
//左 < 父 < 右
//5、循环 while (p != null) { //5.1、当前节点的key和父节点的key进行对比 int cmp = k.compareTo(p.key);
//5.2、key < 父key = 向左树查找 if (cmp < 0) p = p.left; //5.3、key > 父key = 向右树查找 else if (cmp > 0) p = p.right; //5.4、相等则直接返回这个节点 else return p; } return null; } /** * 按照比较器规则进行查找 * @param key * @return Entry<K,V> */ final Entry<K,V> getEntryUsingComparator(Object key) {
//1、强转 @SuppressWarnings("unchecked") K k = (K) key;
//2、获取到比较器 Comparator<? super K> cpr = comparator;
//3、比较器为空，直接返回 if (cpr != null) {
//3.1、从根节点开始，作为父节点进行遍历 Entry<K,V> p = root;
//左 < 父 < 右
while (p != null) { //3.2、当前节点的key和父节点的key进行对比 int cmp = cpr.compare(k, p.key);
//3.3、key < 父key = 向左树查找 if (cmp < 0) p = p.left; //3.4、key > 父key = 向右树查找 else if (cmp > 0) p = p.right; //3.5、相等则直接返回这个节点 else return p; } } return null; } |
删除：
| /** * 根据key进行删除 * @param key 要删除的键 * @return V 返回旧的value */ public V remove(Object key) { //1、根据key查询到对应节点的对象 Entry<K,V> p = getEntry(key);
//2、如果查找不到，则直接返回null if (p == null) return null;
//3、如果查找到了，则获取到这个value V oldValue = p.value;
//4、删除这个查找到K-V deleteEntry(p);
//5、返回旧的value return oldValue; } /** * 从红黑树中删除这个entry * @author suzhiwei * @param p void */ private void deleteEntry(Entry<K,V> p) { //修改次数+1，元素数量-1 modCount++; size--;
//如果被删除的节点p的左节点和右节点都不为空，则查找替代节点，将p的子节点挂到这个替换节点下 if (p.left != null && p.right != null) { //查找p的替代节点，即继承节点 //继承节点为当前节点的右节点或右子节点的最小的左节点 Entry<K,V> s = successor(p);
//K-V替换，但是没有替换颜色 p.key = s.key; p.value = s.value;
//将p指向替代节点，从此p不再是原先要删除的节点p，而是替代者p //即原先要删除的节点是p，p删除了子节点还是存在的，那么则要把子节点挂载到别的节点(s)下，这种情况下找到这个挂载的父节点，将这个节点赋给p，直接删除这个挂载的父节点即可。 // p s // / \ // l r p = s; }
//开始修复树结构，replacement为替代节点p的继承者，怕的左节点存在则用p的左节点替代，否则用右节点 //不可能存在左右节点都存在的情况，因为successor寻找的就是最小的节点，它的左子节点为null Entry<K,V> replacement = (p.left != null ? p.left : p.right);
//如果上面的if有两个节点不通过，这里表示要删除的节点只有一个子节点 if (replacement != null) { //将p的父节点拷贝给替代节点 replacement.parent = p.parent; //如果替代节点p的父节点为空 if (p.parent == null) //p就是根节点，则将replacement设置为替代节点 root = replacement; //如果替代节点p是父节点的左节点，则将replacement设置为其父节点的左节点 else if (p == p.parent.left) p.parent.left = replacement; //如果替代节点p是其父节点的左节点，则将replacement设置为其父节点的右节点 else p.parent.right = replacement;
//将替代节点p的左节点、右节点、父节点都指向为空，即接触前后引用关系（相当于将p从树中删除），使得gc可以回收 p.left = p.right = p.parent = null;
//如果替代节点p的颜色是黑色，则调整红黑树以保持平衡 if (p.color == BLACK) fixAfterDeletion(replacement);
//如果替代节点p没有父节点，代表p为根节点，即直接删除这个节点即可 } else if (p.parent == null) { root = null;
//进入这里的话，就说明替代节点p没有子节点，直接删除即可 } else { //如果p的节点颜色是黑色，则调整红黑树 if (p.color == BLACK) fixAfterDeletion(p);
//下面删除替代节点p if (p.parent != null) { //删除p的父节点对p的引用 if (p == p.parent.left) p.parent.left = null; else if (p == p.parent.right) p.parent.right = null; //删除p对p的父节点的引用 p.parent = null; } } }
/** * 查找要删除的节点的替代节点 * @param t * @return TreeMap.Entry<K,V> */ 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; } }
/** * 删除节点，平衡树 * @param x void */ private void fixAfterDeletion(Entry<K,V> x) { // while循环，保证要删除节点x不是跟节点，并且是黑色（根节点和红色不需要调整） //保证要删除的节点x不是根节点，并颜色是黑色（根节点和红色不需要调整），进入循环 while (x != root && colorOf(x) == BLACK) {
//如果要删除节点x是父节点的左节点 if (x == leftOf(parentOf(x))) { //取出要删除的节点x的兄弟节点，右节点 Entry<K,V> sib = rightOf(parentOf(x));
//如果删除的节点x的兄弟节点-右节点是红色 if (colorOf(sib) == RED) { //改变x的兄弟节点-右节点颜色为黑色 setColor(sib, BLACK); //将x节点的父节点颜色改变为红色 setColor(parentOf(x), RED); //按照x节点的父节点进行左旋 rotateLeft(parentOf(x)); //将x的兄弟节点-右节点重新指向旋转后x的兄弟节点 sib = rightOf(parentOf(x)); }
//如果x的兄弟节点-右节点的两个子节点都是黑色 if (colorOf(leftOf(sib)) == BLACK && colorOf(rightOf(sib)) == BLACK) { //x的兄弟节点-右节点设置为红色 setColor(sib, RED); //将x的父节点指向x，如果x的父节点是黑色，需要将x的父节点看做一个节点继续调整 x = parentOf(x);
//如果x的兄弟节点-右节点的两个子节点，其中一个或两个都不是黑色 } else { //x的兄弟节点-右节点颜色设置和父节点一样 if (colorOf(rightOf(sib)) == BLACK) { //将x的兄弟节点-右节点的左节点设置为黑色 setColor(leftOf(sib), BLACK); //将x的兄弟节点-右节点设置为红色 setColor(sib, RED); //右旋x的兄弟节点 rotateRight(sib); //将x的兄弟节点-右节点重新指向旋转后的x的兄弟节点 sib = rightOf(parentOf(x)); } //如果x的兄弟节点-右节点的右节点是红色 setColor(sib, colorOf(parentOf(x))); //将x的父节点设置为黑色 setColor(parentOf(x), BLACK); //将x的兄弟节点-右节点的右节点设置为黑色 setColor(rightOf(sib), BLACK); //左旋x的父节点 rotateLeft(parentOf(x)); //为了达到平衡，将x指向root，退出循环 x = root; }
//如果要删除节点x是父节点的右节点，和上面情况一样 } else { 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); } |
小结：
红黑树的节点插入操作，首先是改变新节点，新节点的父节点，祖父节点，和新节点的颜色，能在当前分支通过节点的旋转来改变的，通过这个操作来满足红黑树的特点。
如果当前节点的旋转解决不了红黑树的冲突，则通过将红色的节点移动到根节点解决，最后在将根节点设置为黑色。
HashMap通常比TreeMap快一点，树和hash表的数据结构，建议普通操作用HashMap，排序用TreeMap。
红黑树演示网站：https://www.cs.usfca.edu/~galles/visualization/RedBlack.html
