JDK源码学习（4）-java.util.HashMap、LinkedHashMap与TreeMap

一、HashMap
该类的节点Node类为：

static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;

Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}

public final K getKey()        { return key; }
public final V getValue()      { return value; }
public final String toString() { return key + "=" + value; }

public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}

public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}

public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}

该类的变量为

transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
transient int size;

因此HashMap的结构如图1所示：




put方法。该方法向hashMap中增加元素。代码为：

public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//该类的hash方法。如果为空，则返回0；如果不为空，则调用hashCode与h循环右移16 的异或结果。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//1.如果该map为空，则调用resize方法新建数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//2.如果想要插入的节点的hash在tab相应位置上为空，则通过newNode新建节点，并存放到指定的位置上
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//3.如果想要插入的节点的hash在tab相应位置上不为空值，则需要进行其他操作，具体操作见下边注释
else {
//3.1初始化一个临时的节点e
Node<K,V> e; K k;
//3.2如果原有值的hash值与现有值相同，并且key值相同，则将原有的节点值赋值给e
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//3.3如果原有的值和想要插入的节点不同，并且原有的值为TreeNode结构，则e调用treeNode的putTreeVal方法进行赋值
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//3.4如果原有的值和想要插入的节点不同，并且原有的节点也不为TreeNode的结构，则，需要进行以下循环
else {
for (int binCount = 0; ; ++binCount) {
//3.4.1如果原有的位置的节点链表的next即后面的节点为空，则将想要插入的节点放到原有位置的后面，并且跳出循环；如果不为空则判断是否key和hash值相同，如果相同也会替换掉旧的值，否则会一直沿着链表向下，直到找到空的位置可以存放位置。（这块循环主要是为了找到合适存放新节点的位置，具体存放值在后一个逻辑中）
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果链表长度过长，超过TREEIFY_THRESHOLD的值，则将链表转化红黑树。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//3.4.2如果有相同节点的话，直接跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//3.4.3继续开始e的next节点，即p现在指向的是它的后继的节点
p = e;
}
}
//3.5 如果e的值不为空，即key已经存在了，则替换值的内容
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果数组超过阀值，阀值一般为数组总量的0.75，则通过resize（）进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}

主要是调用putVal（hash(key）,key,value,false,true)；
主要功能为：
1)声明四个局部变量。Node<K,V>[] tab Node节点数组类型tab；Node<K,V> p Node节点p；整型变量n与i。
2）将tab赋值成Map类的变量table（即该map的所有节点的数组），n赋值成table的长度，即Map的所有元素数量。
3）该方法的返回值为put后之前的旧值，如果没有旧值则为null
4)如果map为空，则调用resize（）方法。并且将n赋值成resize（）的长度。resize（）方法为：

final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//如果数组容量已经超过最大的限度了，则不进行扩容了，将阀值设置成最大，让数据自行进行碰撞
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果可以扩容，则将容量增加一倍，并且阀值也增加一倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//如果该map为新的map，则进行初始化
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else {               // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//将数组中链表中的每个节点重新存放到新的数据中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}

2.get方法，具体方法如下：

public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}

该方法主要调用getNode（hash（key），key），具体方法如下：

final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//1.根据hash获取到该hash所在的数组的位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//1.1如果该位置的第一个node节点的key是要查的key值，则返回该node节点
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//1.2如果该位置第一个节点不是当前key所要查询的值，则继续查询该节点的后续节点（数组位置相同，但是在该位置的链表中遍历）
if ((e = first.next) != null) {
//1.2.1如果为树形结构，则查询树形结构的节点，关于树形节点的相关知识后面说明。
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//1.2.2遍历链表，找到key值相同的节点
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}

3.hashCode分析

static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

如上所示，key调用了hashcode后得到对象的h值，之后在进行与h的高16位进行异或后的值。
如“abcd”字符串的hashcode值为： 1011011001010001000010
将h循环右移16位后的值为： 0000000000000000101101
因此将两个数字进行异或得到h1为： 1011011001010001101111
假设另一个值结果为h2为： 1011011001010001111111
1）hashMap处理冲突的方式为：h &（n-1）
如果n也就是map的总容量为16则n-1 0000000000000000001111
则计算的结果为： 0000000000000000001111 结果为15
两个数值的结果是一样的，因此存放的位置也是一样的。

2）针对resize（）扩容后会将节点重新计算后存放到新的扩容后的位置上。首先

e.hash & oldCap

以上语句是将节点的hash值与扩容前的map容量进行计算：
假设,两个不同的key进行hash（）操作后获得两个数字分别为h1，h2。如下：
n1为16： 0000000000000000010000 n2为32-1：0000000000000000011111
h1： 1011011001010001101111 值为：00000 1011011001010001101111 值为：01111
h2： 1011011001010001111111 值为：10000 1011011001010001111111 值为：11111
因此通过与n1计算后的结果可以看到，h1节点在resize中判断后发放到loHead节点位置上，h2节点那就要放到hiHead节点的位置上。
而通过与n2计算后的结果可以发现，h2节点相对于之前在16位于16-1计算后结果是与h1相同的，但是在扩容到32位后与n2进行计算后可以发现，h1和h2的结果不同了，h2相当于多了高位一个1，因此相当于加了16即原来扩容前的容量值。因此最后将loHead放到原先的位置，将hiHead放到了原先位置+扩容前容量 的新的位置。

二、LinkedHashMap
该类继承HashMap，实现Map接口。
1.put
该方法LinkedHashMap没有进行重写，直接继承自HashMap的put方法，但是LinkedHashMap重写了HashMap中putVal方法中调用的void afterNodeAccess(Node<K,V> e) 方法。HashMap中afterNnodeAccess方法为空，为进行具体逻辑实现。实现如下：

void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
tail = p;
++modCount;
}
}

该方法主要是将Node放到链表的最后一位，并且将链表设置成双向链表结构。
2.get方法

public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}

每次查找到节点后，会将节点存放到链表的末尾的位置。前提是accessOrder为true，该值默认为false

通过put和get两个方法，就保证了LinkedHashMap后操作的数据的存放位置肯定会在先操作数据的后面。也就是可以保证以下顺序：近期被操作数据在后，近期未被操作的数据在前。

3.afterNodeInsertion方法，也是包含在put中，主要是为了实现LRU中过期数据删除的功能。
其中removeEldestEntry（）方法默认为false，也就是相当于永不过期。
但是如果重写该方法，比如下面当size大于100的时候返回true；进行过期数据删除的功能。

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return size>100;
}

下面方法主要是删除head的节点，即删除头结点。按照上面afterNodeAcess方法越久未被使用的节点越在表头，因此相当于删除过期的数据功能。

void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}

4.根据LinkedHashMap实现LRU的基本机制测试
1）编写子类LinkHashMapExt继承自LinkedHashMap，主要是实现一个构造函数将accessOrder的值设置成true，以便实现在get方法时也会对节点位置进行重置；重写removeEldestEntry方法，完成对过期数据规则的设置。
方法如下：

public class LinkHashMapExt<K, V> extends LinkedHashMap<K, V> {
private static final long serialVersionUID = -6245503866888058349L;
//构造方法主要是初始化一个容量为8的节点数组，碰撞因子为0.75，可显示配置accessOrder
public LinkHashMapExt(boolean accessOrder) {
super(8, 0.75f, accessOrder);
}
//配置过期数据的限制：当Map中数据数量大于2，则删除过期数据
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > 2;
}
}

2）测试该class的客户端程序：

public class TestLinkHashMapExt {

public static void main(String[] args) {
LinkHashMapExt<String, String> treeMapExt = new LinkHashMapExt<String, String>(true);
treeMapExt.put("a", "a");
System.out.println(treeMapExt.get("a"));
treeMapExt.put("b", "b");
1.treeMapExt.get("b");
2.treeMapExt.get("a");
treeMapExt.put("c", "c");
System.out.println(treeMapExt.get("b"));
System.out.println(treeMapExt.get("a"));
System.out.println(treeMapExt.get("c"));
}
}

输出结果一为：

a
null
a
c

如果将代码中的1与2给注释掉，输出结果二为：

a
b
null
c

通过以上两个结果，我们可以发现这样两个功能：

1.在map中有a、b两个元素后，再插入c，由于size>2会删除较旧元素，因此有一个元素返回null。

2.代码中1、2两行给b、a两个元素进行了get操作后，a由于是较后的操作，因此a较新，而b较旧，这样在put新的元素c后，会删除较旧元素，即删除b元素，保留a元素。（如结果一所示）；如果没有代码1、2两行，则a为较旧元素，删除a元素。（如结果二所示）

三、TreeMap
TreeMap的底层数据结构为二叉排序树，构造方法为：

public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}

put方法

public V put(K key, V value) {
//1.找到该TreeMap的根节点root
Entry<K,V> t = root;
//1.1如果根节点为空，则将该插入节点定义为根节点
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;
//2.判断是否有comparator的实现
if (cpr != null) {
//2.1如果有比较方法的实现，则比较要插入的节点的key值与tree的父节点的值，如果大于父节点值，则放到右儿子结点；如果小于父节点值，则放到左儿子结点。如果等于父节点的key值，则直接替换value值。
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);
}//2.2如果没有比较方法的实现，则直接调用默认的比较方法，并与2.1的逻辑相同存放到树形结构上。
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);
}
//3.如果节点未找到相同key，则根据比较的结果将节点插入到当前节点的儿子节点位置
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;
}

下面方法应该是构造红黑树的方法，具体有待研究。感觉前半部分已经实现了一个堆排序的功能了。但是如果节点按照大小顺序进行put，那么堆就会变成一个链表了，效率就会特别低，因此需要进行红黑树调整，具体红黑树的问题需要进行研究。

fixAfterInsertion(e);

本文出自 “yinyueml之家” 博客，请务必保留此出处http://yinyueml.blog.51cto.com/4841237/1770338