Java集合（五）LinkedHashMap、TreeMap
文章目录
Java集合（一）集合框架概述
Java集合（二）List、ArrayList、LinkedList
Java集合（三）CopyOnWriteArrayList、Vector、Stack
Java集合（四）Map、HashMap
Java集合（五）LinkedHashMap、TreeMap
Java集合（六）Hashtable、ConcurrentHashMap
Java集合（七）Set、HashSet、LinkedHashSet、TreeSet
Java集合（八）BlockingQueue、ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、DelayQueue
【LinkedHashMap】
一、LinkedHashMap介绍
LinkedHashMap是有序版本的HashMap。LinkedHashMap是HashMap的子类，所以LinkedHashMap自然会拥有HashMap的所有特性。同时，HashMap是无序的，即迭代HashMap所得到的元素顺序并不是它们最初添加到HashMap的顺序。而LinkedHashMap可以保证迭代元素的顺序与存入容器的顺序一致。
本质上，HashMap和双向链表合二为一就是LinkedHashMap。更准确地说，它是一个将所有Entry节点链入一个双向链表双向链表的HashMap。
一般来说，如果需要使用的Map中的key无序，选择HashMap；如果要求key有序，则选择TreeMap。但是选择TreeMap会有性能问题，因为TreeMap的get操作的时间复杂度是O(log(n))的，相比于HashMap的O(1)还是差不少的，LinkedHashMap的出现就是为了平衡这些因素，使得能够以 O(1)时间复杂度增加查找元素，又能够保证key的有序性。
在HashMap有一些空方法，比如：
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
LinkedHashMap重写了这些方法，用来保持列表的有序。
关于LinkedHashMap和HashMap结构上的差异，如下图所示。
- HashMap的结构
- LinkedHashMap的结构
LinkedHashMap的底层实现：将所有Entry节点链入一个双向链表的HashMap。在LinkedHashMap中，所有put进来的Entry都保存在哈希表中，但由于它又额外定义了一个以head为头结点的双向链表，因此对于每次put进来Entry，除了将其保存到哈希表上外，还会将其插入到双向链表的尾部。
1.1 LinkedHashMap特点*
- 1、由于继承HashMap类，所以默认初始容量是16，加载因子是0.75。
- 2、线程不安全。
- 3、具有fail-fast的特征。
- 4、底层使用双向链表，可以保存元素的插入顺序，顺序有两种方式：一种是按照插入顺序排序，一种按照访问顺序做排序(可以做LRU策略的实现类)。默认以插入顺序排序。
- 5、key和value允许为null，key重复时，新value覆盖旧value，即：最多只允许一条Entry的键为null。
- 6、可以用来实现LRU算法。
- 7、LinkedHashMap与HashMap的存取数据操作基本是一致的，只是增加了双向链表保证数据的有序性。
- 8、LinkedHashMap继承HashMap，基于HashMap+双向链表实现。（HashMap是数组+链表+红黑树实现的）。
1.2 LinkedHashMap的使用
由于LinkedHashMap继承自HashMap，所以HashMap有的方法LinkedHashMap也有，特殊的在于LinkedHashMap中有序性的选择。
因为LinkedHashMap元素的有序性可分为插入顺序性和访问顺序性，所以可以在创建对象时，指定选择哪种顺序。accessOrder为false时，基于插入顺序；accessOrder为true时，基于访问顺序。
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
二、从源码理解LinkedHashMap
2.1 Entry*
LinkedHashMap中存储的节点：
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
LinkedHashMap中的节点Entry，相比于HashMap中的节点Node，多了指向前后位置的节点before和after，用于维护双向链表。
HashMap与LinkedHashMap的Entry结构示意图：
LinkedHashMap中的变量：
private static final long serialVersionUID = 3801124242820219131L;
//头结点
transient LinkedHashMap.Entry<K,V> head;
//尾节点
transient LinkedHashMap.Entry<K,V> tail;
//这个变量决定链表元素的存储方式，false按照存储顺序存储，true表示按照访问顺序
//存储（将最近访问的元素移动到尾部），该变量和LRU算法相关
final boolean accessOrder;
accessOrder默认为false，表示按照插入顺序访问。
2.2 创建LinkedHashMap对象
LinkedHashMap和HashMap的构造方法类似，不过多了accessOrder属性，默认为false，该属性可以手动指定。
//指定初始容量与负载因子
//默认访问顺序标识为false，表示按照插入顺序存储
public LinkedHashMap(int initialCapacity, float loadFactor)
//指定初始容量，负载因子为0.75
//默认访问顺序标识为false，表示按照插入顺序存储
public LinkedHashMap(int initialCapacity)
//默认初始容量(16)和负载因子(0.75)
//默认访问顺序标识为false，表示按照存储顺序存储
public LinkedHashMap()
//指定初始容量与负载因子
//指定默认访问顺序标识
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
2.3 是否包含某个value
在HashMap中，判断一个value是否在容易中，是按数组的方式从头到尾遍历的。LinkedHashMap实现了链表的顺序结构，就用了链表的方式从头到尾遍历
public boolean containsValue(Object value) {
//从向前后进行遍历
for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
V v = e.value;
if (v == value || (value != null && value.equals(v)))
return true;
}
return false;
}
2.4 获取元素
和HashMap类似，获取容器中一个元素的方式有get、getOrDefault两种，获取元素的方式也一致。不同的是，如果LinkedHashMap指定了访问顺序的话，就要将获取的元素放在链表尾部。
public V get(Object key) {
Node<K,V> e;
//第一步是直接使用HashMap中的函数getNode方法，获取value，如果为null，返回null
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
//将添加的元素移动到链表的尾端
afterNodeAccess(e);
return e.value;
}
//将访问的这个元素移动到双向链表的尾端，并且将他的后面的元素向前移动
void afterNodeAccess(Node<K,V> e) {
//last为原链表的尾节点
LinkedHashMapEntry<K,V> last;
//如果accessOrder为true，并且尾端元素不是需要访问的元素
if (accessOrder && (last = tail) != e) {
//将节点e强制转换成linkedHashMapEntry,b为这个节点的前一个
//节点，a为它的后一个节点
LinkedHashMapEntry<K,V> p =
(LinkedHashMapEntry<K,V>)e, b = p.before, a = p.after;
//p为最后一个元素，那么他的后置节点必定是空
p.after = null;
//b为e的前置元素，如果b为空，说明此元素必定是链表的第一个元素，更新之后
//链表的头结点已经变成尾节点，那么原链表的第二个节点就要变为头结点
if (b == null)
head = a;
else
//如果b不是空，那么b的后置节点就由p变为p的后置节点
b.after = a;
//如果p的后置节点不为空，那么更新后置节点a的前置节点为b
if (a != null)
a.before = b;
else
//如果p的后置节点为空，那么p就是尾节点，那么更新last的节点为p的前置节点
last = b;
//如果原来的尾节点为空，那么原链表就只有一个元素
if (last == null)
head = p;
else {
//更新当前节点p的前置节点为 原尾节点last， last的后置节点是p
p.before = last;
last.after = p;
}
//p为最新的尾节点
tail = p;
++modCount;
}
}
这里需要注意两点：一是调用次函数之后，访问的这个元素会移动到双向链表的尾端，二是在accessOrder=true的模式下，迭代LinkedHashMap时，如果同时查询（get）访问数据，也会导致fail-fast，因为迭代的顺序已经改变。
2.5 清空LinkedHashMap
调用了父类HashMap的clear方法（作用是：把数组中所有元素都置为null），并将头尾节点都置为null。
public void clear() {
super.clear();
head = tail = null;
}
2.6 遍历
因为LinkedHashMap中的Entry节点和父类HashMap中的Node节点不同，所以重写了遍历容器中元素的相关方法。在这些方法里都用到了自己实现的迭代器LinkedHashIterator。
//获取key集合
public Set<K> keySet()
//获取value集合
public Collection<V> values()
//获取Entry集合
public Set<Map.Entry<K,V>> entrySet()
LinkedHashMap中的核心迭代器就是LinkedHashIterator，也实现了fail-fast机制。
abstract class LinkedHashIterator {
//下一个节点
LinkedHashMapEntry<K,V> next;
//当前节点
LinkedHashMapEntry<K,V> current;
int expectedModCount;
LinkedHashIterator() {
//初始化的时候将next指向双向链表的头结点
next = head;
expectedModCount = modCount;
//current为空
current = null;
}
public final boolean hasNext() {
return next != null;
}
//nextNode方法就是我们用到的next方法，
//迭代LinkedHashMap，就是从内部维护的双链表的表头开始循环输出
final LinkedHashMapEntry<K,V> nextNode() {
//记录要返回的e
LinkedHashMapEntry<K,V> e = next;
//fail-fast判断
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
//如果返回的是空，则抛出异常
if (e == null)
throw new NoSuchElementException();
//更新当前节点为e
current = e;
//更新下一个节点是e的后置节点
next = e.after;
return e;
}
//删除方法，就直接使用了hashmap的remove
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
LinkedHashMap的迭代器遍历只提供了单向访问，即按照插入的顺序从头到尾进行访问，不能像LinkedList那样进行双向访问。
在新增节点时，已经维护了元素之间的插入顺序了，所以在迭代访问时只需要不断的访问当前节点的下一个节点即可。
2.7 添加元素
由于LinkedHashMap是HashMap的子类，添加元素是通过调用父类的putVal来完成的。在HashMap的putVal方法中，有调用newNode(hash, key, value, null)方法来创建节点的操作。
LinkedHashMap通过newNode/newTreeNode方法进行节点新增。
LinkedHashMap重写的newNode方法：
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<K,V>(hash, key, value, e);
// 将新建的节点添加到双向链表的尾部
linkNodeLast(p);
return p;
}
//在双向链表的尾部添加新建的节点
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
// p为新的需要追加的结点
tail = p;
// 如果last为null.则表示现在链表为空。新new出来的p元素就是链表的头结点
if (last == null)
head = p;
// 否则就是链表中已存在结点的情况：往尾部添加即可
else {
// 把新追加p的结点的前驱结点设置之前的尾部结点
// 把之前的尾部结点的后驱结点设为新追加的p结点
p.before = last;
last.after = p;
}
}
可以看出LinkedHashMap的在新建一个结点的时候，做了两件事：
1）新建结点，并放入到对应的hash桶位置。
2）将新建的结点追加到双向链表的尾部。
结合构造方法来看的话：LinkedHashMap初始化时，accessOrder为false，就会按照插入顺序提供访问，插入方法使用的是父类HashMap的put方法，不过覆写了put方法，执行中调用的是newNode/newTreeNode和afterNodeAccess 方法。
LinkedHashMap通过新增头节点、尾节点，给每个节点增加before、after 属性。每次新增时，都把节点追加到尾节点，这样就可以保证新增节点是按照顺序插入到链表中的。
LinkedHashMap的没有自己的put方法的实现,而是使用父类HashMap的put方法:在正常新增之后,调用afterNodeAccess(e)和 afterNodeInsertion(evict)让LinkedHashMap自己做后续处理：
//回调函数，新节点插入之后回调 ， 根据evict判断是否需要删除最老插入的节点。
void afterNodeInsertion(boolean evict) {
LinkedHashMap.Entry<K,V> first;
//LinkedHashMap 默认返回false 则不删除节点
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
//移动访问的节点到链表末端（该方法在get小节已详细介绍过）
void afterNodeAccess(Node<K,V> e) {
//省略代码....
}
//LinkedHashMap 默认返回false 则不删除节点。 返回true 代表要删除最早的节点。通常构建一个LruCache会在达到Cache的上限是返回true
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
2.8 删除元素
LinkedHashMap删除元素时，也是通过调用父类的方法来实现的。LinkedHashMap在删除元素时，会调用到自己重写的afterNodeRemoval方法：
//在删除节点e时，同步将e从双向链表上删除
void afterNodeRemoval(Node<K,V> e) { // unlink
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
//待删除节点 p 的前置后置节点都置空
p.before = p.after = null;
//如果前置节点是null，则现在的头结点应该是后置节点a
if (b == null)
head = a;
else//否则将前置节点b的后置节点指向a
b.after = a;
//同理如果后置节点时null ，则尾节点应是b
if (a == null)
tail = b;
else//否则更新后置节点a的前置节点为b
a.before = b;
}
【TreeMap】
一、TreeMap介绍
TreeMap是一个能比较元素大小的Map容器，会对传入的key进行了大小排序。可以使用元素的自然顺序，也可以使用集合中自定义的比较器来进行排序。TreeMap是一个通过红黑树实现有序的K-V集合。
对于TreeMap而言，由于它底层采用一棵”红黑树”来保存集合中的Entry，这意味这TreeMap添加元素、取出元素的性能都比HashMap低。当向TreeMap中添加元素时，需要通过循环找到新增Entry的插入位置，因此比较耗性能；当从TreeMap中取出元素时，需要通过循环才能找到合适的Entry，也比较耗性能。
TreeMap比HashMap的优势在于：TreeSet 中所有元素总是根据key的某种指定排序规则保持有序状态。
TreeMap底层基于红黑树实现，可保证在log(n)时间复杂度内完成containsKey、get、put 和 remove 操作，效率很高。
TreeMap的核心是红黑树，其很多方法也是对红黑树增删查基础操作的一个包装。
为了理解TreeMap的底层实现，需要先了解排序二叉树和红黑树这两种数据结构。其中红黑树又是一种特殊的排序二叉树。排序二叉树是一种特殊结构的二叉树，可以非常方便地对树中所有节点进行排序和检索。
- 排序二叉树/二叉查找树
排序二叉树要么是一棵空二叉树，要么是具有下列性质的二叉树：
- 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
- 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
- 它的左、右子树也分别为排序二叉树。
对排序二叉树，若按中序遍历就可以得到由小到大的有序序列。如上图所示二叉树，中序遍历得：{2，3，4，8，9，9，10，13，15，18}。
创建排序二叉树的步骤，也就是不断地向排序二叉树添加节点的过程，向排序二叉树添加节点的步骤：
- 以根节点当前节点开始搜索。
- 拿新节点的值和当前节点的值比较。
- 如果新节点的值更大，则以当前节点的右子节点作为新的当前节点；如果新节点的值更小，则以当前节点的左子节点作为新的当前节点。
- 重复 2、3 两个步骤，直到搜索到合适的叶子节点为止。
- 将新节点添加为第 4 步找到的叶子节点的子节点；如果新节点更大，则添加为右子节点；否则添加为左子节点。
- 红黑树
红黑树是一种自平衡二叉查找树。所谓的平衡树是指一种改进的二叉查找树，顾名思义平衡树就是将二叉查找树平衡均匀地分布，这样的好处就是可以减少二叉查找树的深度。
一般情况下二叉查找树的查询复杂度取决于目标节点到树根的距离（即深度），当节点的深度普遍较大时，查询的平均复杂度就会上升，因此为了实现更高效的查询就有了平衡树。
非平衡二叉树：
平衡二叉树：
可以看出使用平衡二叉树可以有效的减少二叉树的深度，从而提高了查询的效率。
红黑树除了具备二叉查找树的基本特性之外，还具备以下特性：
- 节点是红色或黑色；
- 根节点是黑色；
- 所有叶子都是黑色的空节点（NIL 节点）；
- 每个红色节点必须有两个黑色的子节点，也就是说从每个叶子到根的所有路径上，不能有两个连续的红色节点；
- 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑色节点。
红黑树结构：
红黑树的优势在于它是一个平衡二叉查找树，对于普通的二叉查找树（非平衡二叉查找树）在极端情况下可能会退化为链表的结构，例如，当我们依次插入 3、4、5、6、7、8 这些数据时，二叉树会退化为如下链表结构：
当二叉查找树退化为链表数据结构后，再进行元素的添加、删除以及查询时，它的时间复杂度就会退化为 O(n)；而如果使用红黑树的话，它就会将以上数据转化为平衡二叉查找树，这样就可以更加高效的添加、删除以及查询数据了，这就是红黑树的优势。
红黑树高度依然是平均log(n)，且最坏情况高度不会超过2log(n)。它的添加、删除以及查询数据的时间复杂度为O(logn)。
1.2 TreeMap的特点*
- 1、TreeMap默认会对键进行排序，根据键的自然顺序进行（升序）排序或根据提供的Comparator进行排序。
- 2、TreeMap底层使用的数据结构是二叉树。
- 3、TreeMap是线程不安全的。
- 4、 TreeMap的key不能为null。
- 5、TreeMap的查询、插入、删除效率均没有HashMap高，一般只有要对key排序时才使用TreeMap。
- 6、迭代器是fail-fast的。
1.2TreeMap的使用
- 1、创建TreeMap对象
//使用key的自然排序
public TreeMap()
//指定的比较器
public TreeMap(Comparator<? super K> comparator)
- 2、遍历
//返回key集合
public Set<K> keySet()
//返回value集合
public Collection<V> values()
//返回键值对形成的集合
public Set<Map.Entry<K,V>> entrySet()
- 3、判断是否包含指定key/value
//判断是否包含指定key
public boolean containsKey(Object key)
//判断是否包含指定value
public boolean containsValue(Object value)
- 4、获取特定key
//返回大于等于给定键的最小键
public K ceilingKey(K key)
//返回小于等于给定key的最大key对应的键
public K floorKey(K key)
//返回大于指定key的最小key对应的键
public K higherKey(K key)
//返回最大key对应的键
public K lastKey()
//返回小于指定key的最大key对应的键
public K lowerKey(K key)
//返回最小key
public K firstKey()
5、获取特定K-V
//返回大于等于给定键的最小键对应的键值对
public Map.Entry<K,V> ceilingEntry(K key)
//返回小于等于给定key的最大key对应的键值对
public Map.Entry<K,V> floorEntry(K key)
//返回大于指定key的最小key对应的键值对
public Map.Entry<K,V> higherEntry(K key)
//返回最大key对应的键值对
public Map.Entry<K,V> lastEntry()
//返回小于指定key的最大key对应的键值对
public Map.Entry<K,V> lowerEntry(K key)
//返回最小key对应的键值对
public Map.Entry<K,V> pollFirstEntry()
- 6、添加键值对
public V put(K key, V value)
- 7、删除指定key对应的键值对
public V remove(Object key)
- 8、替换K-V
//替换指定key对应的value
public V replace(K key, V value)
//当键值对都相同时，替换value
public boolean replace(K key, V oldValue, V newValue)
- 9、返回比较器
public Comparator<? super K> comparator()
二、从源码理解TreeMap
TreeMap的成员变量：
//key的比较器
private final Comparator<? super K> comparator;
//根节点
private transient Entry<K,V> root;
//节点的数量
private transient int size = 0;
//修改的次数
private transient int modCount = 0;
2.1 Entry
TreeMap中的节点Entry，包含6种元素：key、value、left、right、parent和color。
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;
//用key，value和父节点构造一个Entry，默认为黑色
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
//...
}
2.2 创建TreeMap对象
//默认构造方法，comparator为空，代表使用key的自然顺序来维持TreeMap的顺序，
//这里要求key必须实现Comparable接口
public TreeMap()
//用指定的比较器构造一个TreeMap
public TreeMap(Comparator<? super K> comparator)
2.3 查询数据
// 根据指定 key 取出对应的 Entry
public V get(Object key) {
Entry<K,V> p = getEntry(key);
// 返回该 Entry 所包含的 value
return (p==null ? null : p. value);
}
final Entry<K,V> getEntry(Object key) {
// 如果 comparator 不为 null，表明程序采用定制排序
if (comparator != null)
// 如果比较器为空，只是用key作为比较器查询
return getEntryUsingComparator(key);
if (key == null)
throw new NullPointerException();
// 将 key 强制类型转换为 Comparable 实例
Comparable<? super K> k = (Comparable<? super K>) key;
// 从树的根节点开始
Entry<K,V> p = root;
// 从root节点开始查找，根据比较器判断是在左子树还是右子树
while (p != null) {
// 拿 key 与当前节点的 key 进行比较
int cmp = k.compareTo(p.key );
// 如果 key 小于当前节点的 key，向"左子树”搜索
if (cmp < 0)
p = p. left;
// 如果 key 大于当前节点的 key，向"右子树”搜索
else if (cmp > 0)
p = p. right;
// 不大于、不小于，就是找到了目标 Entry
else
return p;
}
return null;
}
final Entry<K,V> getEntryUsingComparator(Object key) {
K k = (K) key;
// 获取该 TreeMap 的 comparator
Comparator<? super K> cpr = comparator ;
if (cpr != null) {
// 从根节点开始
Entry<K,V> p = root;
while (p != null) {
// 拿 key 与当前节点的 key 进行比较
int cmp = cpr.compare(k, p.key );
// 如果 key 小于当前节点的 key，向"左子树”搜索
if (cmp < 0)
p = p. left;
// 如果 key 大于当前节点的 key，向"右子树”搜索
else if (cmp > 0)
p = p. right;
// 不大于、不小于，就是找到了目标 Entry
else
return p;
}
}
return null;
}
上面的 getEntry(Object obj) 方法也是充分利用排序二叉树的特征来搜索目标 Entry。从二叉树的根节点开始，如果被搜索节点大于当前节点，向”右子树”搜索；如果被搜索节点小于当前节点，向”左子树”搜索；如果相等，那就是找到了指定节点。
当TreeMap里的comparator != null，表明该TreeMap采用了定制排序，在采用定制排序的方式下，TreeMap采用getEntryUsingComparator(key)方法来根据key获取Entry。
其实getEntry、getEntryUsingComparator 两个方法的实现思路完全类似，只是前者对自然排序的TreeMap获取有效，后者对定制排序的TreeMap有效。
：从内部结构来看，TreeMap本质上就是一棵”红黑树”，TreeMap的每个Entry就是该红黑树的一个节点。
2.4 添加数据
public V put(K key, V value) {
// 先以 t 保存链表的 root 节点
Entry<K,V> t = root;
// 如果 t==null，表明是一个空链表，即该 TreeMap 里没有任何 Entry
if (t == null) {
compare(key, key); // type check
// 将新的 key-value 创建一个 Entry，并将该 Entry 作为 root
root = new Entry<K,V>(key, value, null);
// 设置该 Map 集合的 size 为 1，代表包含一个 Entry
size = 1;
// 记录修改次数为 1
modCount++;
return null;
}
// 记录比较结果
int cmp;
Entry<K,V> parent;
// 当前使用的比较器
Comparator<? super K> cpr = comparator ;
// 如果比较器不为空，就是用指定的比较器来维护TreeMap的元素顺序
if (cpr != null) {
// do while循环，查找key要插入的位置（也就是新节点的父节点是谁）
do {
// 使用 parent 上次循环后的 t 所引用的 Entry
parent = t;
// 拿新插入 key 和 t 的 key 进行比较
cmp = cpr.compare(key, t. key);
// 如果新插入的 key 小于 t 的 key，t 等于 t 的左边节点
if (cmp < 0)
t = t. left;
// 如果新插入的 key 大于 t 的 key，t 等于 t 的右边节点
else if (cmp > 0)
t = t. right;
// 如果当前节点的key和新插入的key相等的话，则覆盖map的value，返回
else
return t.setValue(value);
// 只有当t为null，也就是没有要比较节点的时候，代表已经找到新节点要插入的位置
} while (t != null);
}
else {
// 如果比较器为空，则使用key作为比较器进行比较
// 这里要求key不能为空，并且必须实现Comparable接口
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
do {
// 使用 parent 上次循环后的 t 所引用的 Entry
parent = t;
// 拿新插入 key 和 t 的 key 进行比较
cmp = k.compareTo(t. key);
// 如果新插入的 key 小于 t 的 key，t 等于 t 的左边节点
if (cmp < 0)
t = t. left;
// 如果新插入的 key 大于 t 的 key，t 等于 t 的右边节点
else if (cmp > 0)
t = t. right;
// 如果两个 key 相等，新的 value 覆盖原有的 value,并返回原有的 value
else
return t.setValue(value);
} while (t != null);
}
// 将新插入的节点作为 parent 节点的子节点
Entry<K,V> e = new Entry<K,V>(key, value, parent);
// 如果新插入 key 小于 parent 的 key，则 e 作为 parent 的左子节点
if (cmp < 0)
parent. left = e;
// 如果新插入 key 小于 parent 的 key，则 e 作为 parent 的右子节点
else
parent. right = e;
// 插入新的节点后，为了保持红黑树平衡，对红黑树进行调整
fixAfterInsertion(e);
// map元素个数+1
size++;
modCount++;
return null;
}
/** 新增节点后对红黑树的调整方法 */
private void fixAfterInsertion(Entry<K,V> x) {
// 将新插入节点的颜色设置为红色
x. color = RED;
// while循环，直到 x 节点的父节点不是根，且 x 的父节点不是红色
while (x != null && x != root && x. parent.color == RED) {
// 如果 x 的父节点是其父节点的左子节点
if (parentOf(x) == leftOf(parentOf (parentOf(x)))) {
// 获取 x 的父节点的兄弟节点
Entry<K,V> y = rightOf(parentOf (parentOf(x)));
// 如果 x 的父节点的兄弟节点是红色
if (colorOf(y) == RED) {
// 将x的父节点设置为黑色
setColor(parentOf (x), BLACK);
// 将 x 的父节点的兄弟节点设为黑色
setColor(y, BLACK);
// 将 x 的父节点的父节点设为红色
setColor(parentOf (parentOf(x)), RED);
// 将x指向祖父节点，如果x的祖父节点的父节点是红色，按照上面的步骤继续循环
x = parentOf(parentOf (x));
//如果 x 的父节点的兄弟节点是黑色
} else {
// 如果 x 是其父节点的右子节点
if (x == rightOf( parentOf(x))) {
// 将 x 的父节点设为 x
x = parentOf(x);
rotateLeft(x);
}
//把 x 的父节点设为黑色
setColor(parentOf (x), BLACK);
// 把 x 的父节点的父节点设为红色
setColor(parentOf (parentOf(x)), RED);
// 右旋x的祖父节点
rotateRight( parentOf(parentOf (x)));
}
// 如果 x 的父节点是其父节点的右子节点
} else {
//获取 x 的父节点的兄弟节点
Entry<K,V> y = leftOf(parentOf (parentOf(x)));
// 如果 x 的父节点的兄弟节点是红色
if (colorOf(y) == RED) {
// 将 x 的父节点设为黑色
setColor(parentOf (x), BLACK);
// 将 x 的父节点的兄弟节点设为黑色
setColor(y, BLACK);
// 将 x 的父节点的父节点设为红色
setColor(parentOf (parentOf(x)), RED);
// 将 x 设为 x 的父节点的节点
x = parentOf(parentOf (x));
// 如果 x 的父节点的兄弟节点是黑色
} else {
// 如果 x 是其父节点的左子节点
if (x == leftOf( parentOf(x))) {
// 将 x 的父节点设为 x
x = parentOf(x);
rotateRight(x);
}
// 把 x 的父节点设为黑色
setColor(parentOf (x), BLACK);
// 把 x 的父节点的父节点设为红色
setColor(parentOf (parentOf(x)), RED);
rotateLeft( parentOf(parentOf (x)));
}
}
}
// 最后将根节点设置为黑色，不管当前是不是红色，反正根节点必须是黑色
root.color = BLACK;
}
/**
* 对红黑树的节点(x)进行左旋转
* 左旋示意图(对节点x进行左旋)：
* px px
* / /
* x y
* / \ --(左旋)-- / \
* lx y x ry
* / \ / \
* ly ry lx ly
*
*/
private void rotateLeft(Entry<K,V> p) {
if (p != null) {
// 取得要选择节点p的右孩子
Entry<K,V> r = p. right;
// "p"和"r的左孩子"的相互指向...
// 将"r的左孩子"设为"p的右孩子"
p. right = r.left ;
// 如果r的左孩子非空，将"p"设为"r的左孩子的父亲"
if (r.left != null)
r. left.parent = p;
// "p的父亲"和"r"的相互指向...
// 将"p的父亲"设为"y的父亲"
r. parent = p.parent ;
// 如果"p的父亲"是空节点，则将r设为根节点
if (p.parent == null)
root = r;
// 如果p是它父节点的左孩子，则将r设为"p的父节点的左孩子"
else if (p.parent. left == p)
p. parent.left = r;
else
// 如果p是它父节点的左孩子，则将r设为"p的父节点的左孩子"
p. parent.right = r;
// "p"和"r"的相互指向...
// 将"p"设为"r的左孩子"
r. left = p;
// 将"p的父节点"设为"r"
p. parent = r;
}
}
/**
* 对红黑树的节点进行右旋转
* 右旋示意图(对节点y进行右旋)：
* py py
* / /
* y x
* / \ --(右旋)-- / \
* x ry lx y
* / \ / \
* lx rx rx ry
*/
private void rotateRight(Entry<K,V> p) {
if (p != null) {
// 取得要选择节点p的左孩子
Entry<K,V> l = p. left;
// 将"l的右孩子"设为"p的左孩子"
p. left = l.right ;
// 如果"l的右孩子"不为空的话，将"p"设为"l的右孩子的父亲"
if (l.right != null) l. right.parent = p;
// 将"p的父亲"设为"l的父亲"
l. parent = p.parent ;
// 如果"p的父亲"是空节点，则将l设为根节点
if (p.parent == null)
root = l;
// 如果p是它父节点的右孩子，则将l设为"p的父节点的右孩子"
else if (p.parent. right == p)
p. parent.right = l;
//如果p是它父节点的左孩子，将l设为"p的父节点的左孩子"
else p.parent .left = l;
// 将"p"设为"l的右孩子"
l. right = p;
// 将"l"设为"p父节点"
p. parent = l;
}
}
每当程序希望添加新节点时：系统总是从树的根节点开始比较 —— 即将根节点当成当前节点，如果新增节点大于当前节点、并且当前节点的右子节点存在，则以右子节点作为当前节点；如果新增节点小于当前节点、并且当前节点的左子节点存在，则以左子节点作为当前节点；如果新增节点等于当前节点，则用新增节点覆盖当前节点，并结束循环 ——直到找到某个节点的左、右子节点不存在，将新节点添加该节点的子节点 —— 如果新节点比该节点大，则添加为右子节点；如果新节点比该节点小，则添加为左子节点。
- 添加节点后的红黑树调整
每次插入节点后必须进行简单修复，使该排序二叉树满足红黑树的要求。
在插入操作中，红黑树的性质 1 和性质 3 两个永远不会发生改变，因此无需考虑红黑树的这两个特性。
插入操作按如下步骤进行：1.）以排序二叉树的方法插入新节点，并将它设为红色。2）进行颜色调换和树旋转。
假设把新插入的节点定义为N 节点，N 节点的父节点定义为 P 节点，P 节点的兄弟节点定义为 U 节点，P 节点父节点定义为 G 节点。 - 情形 1：新节点 N 是树的根节点，没有父节点
在这种情形下，直接将它设置为黑色以满足性质 2。 - 情形 2：新节点的父节点 P 是黑色
在这种情况下，新插入的节点是红色的，因此依然满足性质 4。而且因为新节点 N 有两个黑色叶子节点；但是由于新节点 N 是红色，通过它的每个子节点的路径依然保持相同的黑色节点数，因此依然满足性质 5。 - 情形 3：如果父节点 P 和父节点的兄弟节点 U 都是红色
在这种情况下，程序应该将 P 节点、U 节点都设置为黑色，并将 P 节点的父节点设为红色（用来保持性质 5）。现在新节点 N 有了一个黑色的父节点 P。由于从 P 节点、U 节点到根节点的任何路径都必须通过 G 节点，在这些路径上的黑节点数目没有改变（原来有叶子和 G 节点两个黑色节点，现在有叶子和 P两个黑色节点）。
经过上面处理后，红色的 G 节点的父节点也有可能是红色的，这就违反了性质 4，因此还需要对 G 节点递归地进行整个过程（把 G 当成是新插入的节点进行处理即可）。示例：
- 情形 4：父节点 P 是红色、而其兄弟节点 U 是黑色或缺少；且新节点 N 是父节点 P 的右子节点，而父节点 P 又是其父节点 G 的左子节点
在这种情形下，我们进行一次左旋转对新节点和其父节点进行，接着按情形 5 处理以前的父节点 P（也就是把 P 当成新插入的节点即可）。这导致某些路径通过它们以前不通过的新节点 N 或父节点 P 的其中之一，但是这两个节点都是红色的，因此不会影响性质 5。示例：
- 情形 5：父节点 P 是红色、而其兄弟节点 U 是黑色或缺少；且新节点 N 是其父节点的左子节点，而父节点 P 又是其父节点 G 的左子节点
在这种情形下，需要对节点 G 的一次右旋转，在旋转产生的树中，以前的父节点 P 现在是新节点 N 和节点 G 的父节点。由于以前的节点 G 是黑色，否则父节点 P 就不可能是红色，我们切换以前的父节点 P和节点 G 的颜色，使之满足性质 4，性质 5 也仍然保持满足，因为通过这三个节点中任何一个的所有路径以前都通过节点 G，现在它们都通过以前的父节点 P。在各自的情形下，这都是三个节点中唯一的黑色节点。示例：
2.5 删除数据
当程序从排序二叉树中删除一个节点之后，为了让它依然保持为排序二叉树，程序必须对该排序二叉树进行维护。维护可分为如下几种情况：
1）被删除的节点是叶子节点，则只需将它从其父节点中删除即可。
2）被删除节点 p 只有左子树，将 p 的左子树 pL 添加成 p 的父节点的左子树即可；被删除节点 p 只有右子树，将 p 的右子树 pR 添加成 p 的父节点的右子树即可。
3）若被删除节点 p 的左、右子树均非空，有两种做法：
- 将 pL 设为 p 的父节点 q 的左或右子节点（取决于 p 是其父节点 q 的左、右子节点），将 pR 设为p 节点的中序前趋节点 s 的右子节点（s 是 pL 最右下的节点，也就是 pL 子树中最大的节点）。
- 以 p 节点的中序前趋或后继替代 p 所指节点，然后再从原排序二叉树中删去中序前趋或后继节点即可。（也就是用大于 p 的最小节点或小于 p 的最大节点代替 p 节点即可）。
被删除节点只有右子树的示意图：
被删除节点既有左子节点，又有右子节点的情形，此时我们采用到是第一种方式进行维护：
被删除节点既有左子树，又有右子树的情形，此时我们采用到是第二种方式进行维护：
TreeMap 删除节点采用最后一张图所示右边的情形进行维护——也就是用被删除节点的右子树中最小节点与被删节点交换的方式进行维护。
public V remove(Object key) {
// 根据key查找到对应的节点对象
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
// 记录key对应的value，供返回使用
V oldValue = p.value;
// 删除节点
deleteEntry(p);
return oldValue;
}
private void deleteEntry(Entry<K,V> p) {
modCount++;
// map容器的元素个数减一
size--;
// // 如果被删除节点的左子树、右子树都不为空
if (p.left != null && p. right != null) {
// 用 p 节点的中序后继节点代替 p 节点
Entry<K,V> s = successor (p);
p. key = s.key ;
p. value = s.value ;
// 将p指向替代节点，从此之后的p不再是原先要删除的节点p，而是替代者p
p = s;
} // p has 2 children
// 如果 p 节点的左节点存在，replacement 代表左节点；否则代表右节点
Entry<K,V> replacement = (p. left != null ? p.left : p. right);
if (replacement != null) { // 如果上面的if有两个孩子不通过--------------这里表示要删除的节点只有一个孩子（2）
// Link replacement to parent
// 将p的父节点拷贝给替代节点
replacement. parent = p.parent ;
// 如果 p 没有父节点，则 replacemment 变成父节点
if (p.parent == null)
root = replacement;
// 如果 p 节点是其父节点的左子节点
else if (p == p.parent. left)
p. parent.left = replacement;
// 如果 p 节点是其父节点的右子节点
else
p. parent.right = replacement;
// 将替代节点p的left、right、parent的指针都指向空，即解除前后引用关系（相当于将p从树种摘除），使得gc可以回收
p. left = p.right = p.parent = null;
// Fix replacement
// 如果替代节点p的颜色是黑色，则需要调整红黑树以保持其平衡
if (p.color == BLACK)
fixAfterDeletion(replacement);
//如果 p 节点没有父节点
} else if (p.parent == null) { // return if we are the only node.
// 如果要替代节点p没有父节点，代表p为根节点，直接删除即可
root = null;
} else { // No children. Use self as phantom replacement and unlink.
// 判断进入这里说明替代节点p没有孩子--------------这里表示没有孩子则直接删除（1）
// 如果p的颜色是黑色，则调整红黑树
if (p.color == BLACK)
fixAfterDeletion(p);
// 下面删除替代节点p
if (p.parent != null) {
// 如果 p 是其父节点的左子节点
if (p == p.parent .left)
p. parent.left = null;
//如果 p 是其父节点的右子节点
else if (p == p.parent. right)
p. parent.right = null;
// 解除p对p父节点的引用
p. parent = null;
}
}
}
/**
* 查找要删除节点的替代节点
*/
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;
}
}
/**删除节点后修复红黑树 */
private void fixAfterDeletion(Entry<K,V> x) {
// 直到 x 不是根节点，且 x 的颜色是黑色
while (x != root && colorOf (x) == BLACK) {
// 如果 x 是其父节点的左子节点
if (x == leftOf( parentOf(x))) {
// 获取 x 节点的兄弟节点
Entry<K,V> sib = rightOf(parentOf (x));
// 如果 sib 节点是红色
if (colorOf(sib) == RED) {
// 将 sib 节点设为黑色
setColor(sib, BLACK);
// 将 x 的父节点设为红色
setColor(parentOf (x), RED);
// 左旋x的父节点
rotateLeft( parentOf(x));
// 再次将 sib 设为 x 的父节点的右子节点
sib = rightOf(parentOf (x));
}
// 如果 sib 的两个子节点都是黑色
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf (sib)) == BLACK) {
// 将 sib 设为红色
setColor(sib, RED);
// 让 x 等于 x 的父节点
x = parentOf(x);
} else {
// 如果 sib 的只有右子节点是黑色
if (colorOf(rightOf(sib)) == BLACK) {
// 将 sib 的左子节点也设为黑色
setColor(leftOf (sib), BLACK);
// 将 sib 设为红色
setColor(sib, RED);
// 右旋x的兄弟节点
rotateRight(sib);
// 将sib重新指向旋转后x的兄弟节点，进入步奏⑤
sib = rightOf(parentOf (x));
}
// 设置 sib 的颜色与 x 的父节点的颜色相同
setColor(sib, colorOf (parentOf(x)));
// 将 x 的父节点设为黑色
setColor(parentOf (x), BLACK);
// 将 sib 的右子节点设为黑色
setColor(rightOf (sib), BLACK);
// 左旋x的父节点
rotateLeft( parentOf(x));
// 达到平衡，将x指向root，退出循环
x = root;
}
// 如果 x 是其父节点的右子节点
} else {
// 获取 x 节点的兄弟节点
Entry<K,V> sib = leftOf(parentOf (x));
// 如果 sib 的颜色是红色
if (colorOf(sib) == RED) {
// 将 sib 的颜色设为黑色
setColor(sib, BLACK);
// 将 sib 的父节点设为红色
setColor(parentOf (x), RED);
rotateRight( parentOf(x));
sib = leftOf(parentOf (x));
}
// 如果 sib 的两个子节点都是黑色
if (colorOf(rightOf(sib)) == BLACK &&
colorOf(leftOf (sib)) == BLACK) {
// 将 sib 设为红色
setColor(sib, RED);
// 让 x 等于 x 的父节点
x = parentOf(x);
} else {
// 如果 sib 只有左子节点是黑色
if (colorOf(leftOf(sib)) == BLACK) {
// 将 sib 的右子节点也设为黑色
setColor(rightOf (sib), BLACK);
// 将 sib 设为红色
setColor(sib, RED);
rotateLeft(sib);
sib = leftOf(parentOf (x));
}
// 将 sib 的颜色设为与 x 的父节点颜色相同
setColor(sib, colorOf (parentOf(x)));
// 将 x 的父节点设为黑色
setColor(parentOf (x), BLACK);
// 将 sib 的左子节点设为黑色
setColor(leftOf (sib), BLACK);
rotateRight( parentOf(x));
x = root;
}
}
}
setColor(x, BLACK);
}
与添加节点之后的修复类似的是，TreeMap删除节点之后也需要进行类似的修复操作，通过这种修复来保证该排序二叉树依然满足红黑树特征。可以参考插入节点之后的修复来分析删除之后的修复。