集合中真正的重头戏，TreeMap集合，TreeMap集合的底层是红黑树结构，前面我们简单的介绍了一下红黑树结构，仅仅是简单的介绍，就是添加一个节点时，红黑树的结构维护。其实，红黑树的删除，也是一个不小的工程。红黑树的删除，我就不单独介绍了，就根据TreeMap集合的删除源码介绍了。
容器篇也快介绍完了，介绍完了TreeMap集合后，还有一个TreeSet集合，其实大家都知道TreeSet集合的底层是TreeMap集合，所以，TreeSet集合的介绍篇幅也会比较小。其实我们介绍这几个集合，大家会发现，他们都不是线程安全的，所以我也会在最好简单介绍一个两个线程安全的集合，一个是HashTable，一个是ConcurrentHashMap。
好了，现在正式开始TreeMap源码的介绍。
先看一下类TreeMap的定义，TreeMap继承了AbstractMap集合实现了NavigableMap接口，而NavigableMap接口有继承了SortedMap接口，SortedMap接口有继承了Map接口。
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable
public interface NavigableMap<K,V> extends SortedMap<K,V> {
public interface SortedMap<K,V> extends Map<K,V>
既然TreeMap结合的底层是红黑树结构，那么，我们先来看一下在java中红黑树结构是怎么表示的。
private static final boolean RED = false;//red=false private static final boolean BLACK = true;//black=true
/*
树形结构，底层是一个红黑树，
*/
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;//key
V value;//value
Entry<K,V> left;//左节点
Entry<K,V> right;//右节点
Entry<K,V> parent;//父节点
boolean color = BLACK;//色域，read或者是black
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
/**
将value值替换
*/
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;
}
}
——TreeMap集合的成员变量 private final Comparator<? super K> comparator;//Comparator维护了一个变量，如果这个变量为null，使用自然顺序排序
private transient Entry<K,V> root;//红黑树的根节点root
private transient int size = 0;//红黑树的大小
private transient int modCount = 0;//结构性修改的次数
——TreeMap集合的构造方法
//无参构造器，使用的是自然排序
public TreeMap() {
comparator = null;
}
//指定了排序方式
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
//一个map集合为参数的构造器，使用的是自然排序
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);//添加，将map转成TreeMap
}
//一个SortedMap为参数，
public TreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();//SortedMap的子类必定实现了comparator()方法，并且返回的是Comparator<? super K>类型
try {
///如果传入的是一个SortedMap类型，使用buildFromSorted转化为TreeMap
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}
第四个构造方法调用了一个buildFromSorted(),所以我们来看一下，buildFromSorted()方法如何转化一个红黑树结构的。private void buildFromSorted(int size, Iterator<?> it,
java.io.ObjectInputStream str,
V defaultVal)
throws java.io.IOException, ClassNotFoundException {
this.size = size;
root = buildFromSorted(0, 0, size-1, computeRedLevel(size),
it, str, defaultVal);
} 先放这儿吧，一会在来分析。
——TreeMap集合的添加操作
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;
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);//key值相等，替换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;
//在此之前的插入，仅仅是put平衡二叉树，并不是红黑树结构
fixAfterInsertion(e);//这一个方法，是真正的变成了红黑树结构
size++;
modCount++;
return null;
}
在fixAfterInsertion()方法之前的操作，并没有考虑红黑树的成立的条件，只是简单的二叉树的插入，如果是自然顺序插入，就是比较，小于的数是该节点的左孩子，大于的数是该节点的右孩子。指定了顺序，也是进行比较，只不过比较的方法不同，孩子节点的放置位置有可能不同。下面看一下fixAfterInsertion()是怎样变成红黑树结构的。
/*
这个方法，是作用就是插入数据时维护红黑树关系
*/
private void fixAfterInsertion(Entry<K,V> x) {
//在此之前，必须了解红黑树，是怎么回事，了解以后，会非常容易了解该方法
x.color = RED;//设置色域为红色，所有插入的元素都是红色
while (x != null && x != root && x.parent.color == RED) {
//x不为null，x不是root，x的父节点是红色，就需要改变，
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
//parentOf(x)，x节点为null，返回null，否则返回父节点。
//判断x节点的祖父节点的左孩子节点==该节点的父节点--》就是说x的父节点是左树
Entry<K,V> y = rightOf(parentOf(parentOf(x)));//获得x节点的父节点的右兄弟
////变色操作
if (colorOf(y) == RED) {
//右叔父节点为红色，就是说，父辈节点都是红色
setColor(parentOf(x), BLACK);//将父节点的色域设置为黑色
setColor(y, BLACK);//将叔父节点也设置为黑色
setColor(parentOf(parentOf(x)), RED);//将祖父节点设置为红色
x = parentOf(parentOf(x));//把祖父节点当做当前节点
} else {
//父节点是红色，叔父节点是黑色
if (x == rightOf(parentOf(x))) {
//如果x节点是右子树
x = parentOf(x);//获得该节点的父节点
rotateLeft(x);//左旋
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));//右旋
}
} else {
//就是说x的父节点是右树
Entry<K,V> y = leftOf(parentOf(parentOf(x)));//获得x的父节点的左兄弟
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);//右旋
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));//左旋
}
}
}
root.color = BLACK;
}
还有左旋和右旋操作。感觉旋转应该时没有什么难度，只要你明白旋转，以下代码自己都可以推理出来。所以就不分析了。
/*
左旋
*/
private void rotateLeft(Entry<K,V> p) {
if (p != null) {
//当前节点不为null
Entry<K,V> r = p.right;//获得当前节点的右孩子节点
p.right = r.left;//当前节点的右孩子节点=右孩子节点的左孩子节点
if (r.left != null)
r.left.parent = p;
r.parent = p.parent;
if (p.parent == null)
root = r;
else if (p.parent.left == p)
p.parent.left = r;
else
p.parent.right = r;
r.left = p;
p.parent = r;
}
}
/*
右旋
*/
private void rotateRight(Entry<K,V> p) {
if (p != null) {
Entry<K,V> l = p.left;
p.left = l.right;
if (l.right != null) l.right.parent = p;
l.parent = p.parent;
if (p.parent == null)
root = l;
else if (p.parent.right == p)
p.parent.right = l;
else p.parent.left = l;
l.right = p;
p.parent = l;
}
}
putAll() /*
将一个map集合添加到TreeMap中
*/
public void putAll(Map<? extends K, ? extends V> map) {
int mapSize = map.size();//先判断map的长度
if (size==0 && mapSize!=0 && map instanceof SortedMap) {
//如果为空，map不是空，map是SortedMap类型
Comparator<?> c = ((SortedMap<?,?>)map).comparator();
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;
}
}
super.putAll(map);
/*
调用的还是父类的的putAll()，父类的putAll()会遍历map集合，然后循环调用put方法，进行添加，多态
*/
}
——TreeMap集合的获取操作(其实获取操作还是较多的) /*
根据key获得指定的value
*/
public V get(Object key) {
Entry<K,V> p = getEntry(key);//调用了getEntry()方法，下面会分析
return (p==null ? null : p.value);
}
/*
获取第一个key，获得的是最左边的节点
*/
public K firstKey() {
return key(getFirstEntry());
}
/*
获得最右边的节点的key值
*/
public K lastKey() {
return key(getLastEntry());
}
/*
getFirstEntry()是final类型的，firstEntry()是程序员可以调用的，返回的数据只包含key和value
*/
public Map.Entry<K,V> firstEntry() {
return exportEntry(getFirstEntry());
}
/*
和firstEntry一样，只是获得的是最大值，
*/
public Map.Entry<K,V> lastEntry() {
return exportEntry(getLastEntry());
}
final Entry<K,V> getEntry(Object key) {
// Offload comparator-based version for sake of performance
if (comparator != null)
//comparator不为null，证明，指定了排序方式
return getEntryUsingComparator(key);//调用了getEntryUsingComparator()方法
if (key == null)
//key为空，报错
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
Entry<K,V> p = root;
while (p != null) {
/*
compareTo,是两个相同数据类型进行比较，如果相等，返回0，如果指定的数大于参数返回 1，如果指定的数小于参数返回 -1
遍历，大于，搜索右树，小于，搜索左树
*/
int cmp = k.compareTo(p.key);
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
return null;
}
/*
* 这个方法，名字是getFirstEntry，其实就是获得最左边的那个节点，就是那个最小的值
*/
final Entry<K,V> getFirstEntry() {
Entry<K,V> p = root;
if (p != null)
while (p.left != null)
p = p.left;
return p;
}
/**
获得最右边的节点，其实就是获得最右边的那个节点，就是那个最大的值
*/
final Entry<K,V> getLastEntry() {
Entry<K,V> p = root;
if (p != null)
while (p.right != null)
p = p.right;
return p;
}
/*
制定了排序方式，调用此方法，获得节点
*/
final Entry<K,V> getEntryUsingComparator(Object key) {
//自上而下进行搜索
@SuppressWarnings("unchecked")
K k = (K) key;
Comparator<? super K> cpr = comparator;
if (cpr != null) {
Entry<K,V> p = root;
while (p != null) {
int cmp = cpr.compare(k, p.key);//进行比较，compare(a,b),a>b ，返回1,a<b返回-1，a=b返回0
if (cmp < 0)
//左节点
p = p.left;
else if (cmp > 0)
//右节点
p = p.right;
else
//相等，
return p;
}
}
return null;
}
/**
SimpleImmutableEntry是一个简单数据类型，只包含key和value值，调用此方法，主要作用就是
只返回给用户相应的key和value值，底层结构的数据，程序员并不需要知道，也不想让用户知道
*/
static <K,V> Map.Entry<K,V> exportEntry(TreeMap.Entry<K,V> e) {
return (e == null) ? null :
new AbstractMap.SimpleImmutableEntry<>(e);
}
——TreeMap集合的删除操作(也是比较复杂，红黑树一章也仅仅是了解了一个插入，没有了解删除)
/*
删除节点，如果该节点不存在，返回null，如果存在，返回该节点的value值
*/
public V remove(Object key) {
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);//删除节点，此为删除节点的实际方法
return oldValue;
}
先上一张图，这张图也是我从网上下找的，感觉对删除节点的流程分析的分析的清楚。再次声明，这张图是我从网上找的。图片上有原创的地址。 /*
* 删除节点的实际方法
*/
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
if (p.left != null && p.right != null) {
//既有左孩子又有右孩子时
Entry<K,V> s = successor(p);//因为左孩子和右孩子都不为null，而successor(),首先获得的就是在右子树最左边的孩子，就是
//右子树中最小的值，替换(原理就是，在删除该节点的右子树中，找到略大于该节点的一个节点即可)
p.key = s.key;
p.value = s.value;
p = s;//将s节点传给p节点
}
Entry<K,V> replacement = (p.left != null ? p.left : p.right);//寻找替代节点，如果该节点没有两个子节点，就找一个孩子作为
//替代节点
/*
如果有两个孩子，经过上面那个if语句后，p节点的值已经被替换(相当于删除)了，s节点肯定是右子树最左边的节点，那么，这是s节点是没有左孩子的，因为s
节点就是最左边的孩子，所以，s节点可能有右孩子，如果有右孩子，就需要将这个s节点的右孩子称为s节点父节点的左孩子
*/
if (replacement != null) {
// Link replacement to parent
replacement.parent = p.parent;//替代节点的父节点指向p的父节点
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;//已替换后，将要删除的p节点的left，right，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
//就是s节点下面无子节点
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;
}
}
} 删除的是黑色节点，必须重新维护红黑树关系，为什么删除的是黑色，就要维护呢？
:因为删除的是红色节点，并不影响每条路径上的黑色节点的个数，但是删除一个黑色节点，会影响，所以必须维护。
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) {
//这个节点为黑色
if (x == leftOf(parentOf(x))) {
//前提1.如果这个节点是左孩子
Entry<K,V> sib = rightOf(parentOf(x));//获得当前节点的父节点的右孩子(就是当前节点的右兄弟)，
if (colorOf(sib) == RED) {
//当前节点的右兄弟是红色，
setColor(sib, BLACK);//有右兄弟变黑色
setColor(parentOf(x), RED);//父节点变红色
rotateLeft(parentOf(x));//以父节点为支点进行左旋
sib = rightOf(parentOf(x));//获得左旋以后，父节点的右孩子
}
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {
//父节点f的右孩子fr1的两个孩子，都是黑色的
setColor(sib, RED);//设置fr1为红色
x = parentOf(x);//将父节点f设置为当前节点
} else {
if (colorOf(rightOf(sib)) == BLACK) {
//右节点为黑色
setColor(leftOf(sib), BLACK);//将左节点也设置为黑色
setColor(sib, RED);
rotateRight(sib);//右旋
sib = rightOf(parentOf(x));//获得旋转后，当前节点的父节点的右孩子
}
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
}
} else { // symmetric
//这个节点是右孩子
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);
}
——TreeMap集合的其他操作 /*
大小
*/
public int size() {
return size;
}
/*
是否包含指定的key的节点
*/
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
/*
是否包含指定value值得节点
*/
public boolean containsValue(Object value) {
for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e))
//循环遍历，successor()方法就相当于i++，一个节点一个节点的指向
if (valEquals(value, e.value))
return true;
return false;
}
/*
返回一个comparator，comparator是该类的一个成员变量，已经被定义好了
*/
public Comparator<? super K> comparator() {
return comparator;
}
/*
清除TreeMap
*/
public void clear() {
modCount++;
size = 0;
root = null;
}
/*
复制
*/
public Object clone() {
TreeMap<?,?> clone;
try {
clone = (TreeMap<?,?>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
// Put clone into "virgin" state (except for comparator)
clone.root = null;
clone.size = 0;
clone.modCount = 0;
clone.entrySet = null;
clone.navigableKeySet = null;
clone.descendingMap = null;
// Initialize clone with our mappings
try {
clone.buildFromSorted(size, entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
return clone;
}
——TreeMap集合的映射操作(视图的方法也是超级多，这里就分析最常用的吧) private transient EntrySet entrySet;//将节点(key-value映射)保存到set集合中
private transient KeySet<K> navigableKeySet;//获得所有key值，保存到set集合中
private transient NavigableMap<K,V> descendingMap;//将map集合逆序
/*
返回此映射包含的键的 Set 视图
*/
public Set<K> keySet() {
return navigableKeySet();
}
/*
将所有的key封装在一个set集合中
*/
public NavigableSet<K> navigableKeySet() {
KeySet<K> nks = navigableKeySet;
return (nks != null) ? nks : (navigableKeySet = new KeySet<>(this));
//nks不为null，返回nks，为null，将这个map集合封装为一个一个KeySet对象
}
/*
返回所有的value值封装到一个collection中
*/
public Collection<V> values() {
Collection<V> vs = values;
return (vs != null) ? vs : (values = new Values());
}
/*
将所用映射关系封装到set集合中
*/
public Set<Map.Entry<K,V>> entrySet() {
EntrySet es = entrySet;
return (es != null) ? es : (entrySet = new EntrySet());
}
好了，TreeMap的分析这样了，我的分析仅供参考，并且代码很多，我也不可能全部都分析一遍，只是将将最常用的方法，和底层的数据结构操作分析了一遍。还是需要自己在电脑上好好的，仔细的看一遍了。TreeMap的常用的方法有很多，其实最终都是调用的那几个方法，其实有些方法简单看一下就可以了，很简单。顺便配上jdk api，感觉也就是这样的。
下一篇，TreeSet集合。我感觉自己的排版好尴尬，大家将就着看吧。