HashMap
HashMap可以看成是一个 `数组+链表/红黑树` 组合成的数据结构。
HashMap，HashTable，ConcurrentHashMap是基于hash表的实现，HashTable和HashMap在代码实现上，基本上是一样的，一个是线程安全的，一个非线程安全。ConcurrentHashMap也是线程安全的，但性能比HashTable好。
重要点
在hashMap中放入（put）元素，有以下重要步骤：
- 计算key的hash值，获得元素在底层数组中的下标。
- 通过下标位置定位到底层数组里的元素。
- 取到第一个元素，判断放入元素的key和当前位置的key是否==或者equals，成立则替换value值，返回旧值。
- 如果是树，循环树中的节点，判断放入元素的key和当前节点的key是否==或者equals，成立则替换树里的value，并返回旧值，不成立就添加到树里。
- 第一个元素不匹配就顺着元素的链表结构循环节点，判断放入元素的key是否==或equals节点的key，成立则替换链表里value，并返回旧值，找不到就添加到链表的最后。
判断放入HashMap中的元素要不要替换当前节点的元素，key满足以下两个条件即可替换：
- 1、hash值相等。
- 2、==或equals的结果为true。
由于hash算法依赖于对象本身的hashCode方法，所以对于HashMap里的元素来说，hashCode方法和equals方法非常重要，所以equals方法和hashCode方法一般是绑定重写的, 否则会造成hashMap运行结果不正确！
几个常量
static final float DEFAULT_LOAD_FACTOR = 0.75f; //负载因子
transient int size; //逻辑长度
transient int modCount; //修改次数, 用于fail-fast
int threshold; //阈值，用于扩容，一般等于 （loadFactor * capacity）
//没有空数组初始化会造成空指针异常
static final Node<?,?>[] EMPTY_TABLE = {};
//HashMap的主干数组，就是一个Node数组，初始值为空数组{}，主干数组的长度一定是2的次幂。
transient Node<K,V>[] table = (Node<K,V>[]) EMPTY_TABLE;
static final int TREEIFY_THRESHOLD = 8; //链表红黑树转换阈值数组元素
数组里原对象是Node。
static class Node<K，V> implements Map.Entry<K，V>{
final int hash; //hash值
final K key;
V value;
Node<K，V> next; //指向下一个Node的引用，组成链表结构
Node(int hash, K key, V value, Node<K,V> next) {
//...省略构造函数
}
}添加Key-Value对
public V put(K key, V value){
return putVal(hash(key), key, value, false, true);
}计算hash值
static fianl 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;
/**添加元素时table为空，触发resize（）**/
if((tab = table)==null || (n = table.length) == 0)
n = (tab.resize()).length;
/** 添加元素时 @if tab[i]位置上没有元素，直接添加
* n为table的逻辑长度，即size
* i = (n - 1) & hash 算法可以保证 i 在 n-1 和 hash 之间
* @else 遍历 通过equals和==判断链表上key和hash是否和目标相同，
* 是则替换，否则添加至链表尾部
**/
//1。从底层数组取值
if((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); //数组元素转成一个单向链表
else{
Node<K,V> e; K k;
//2。底层数组元素匹配成功，赋值给e
if((hash == p.hash) &&
((k = p.key) == key || (key != null && key.equals(k)))
e = p;
//3。树结构处理
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//4。底层数组第一个没匹配上，遍历查询匹配
else {
for (int binCount = 0; ; ++binCount) {
//添加元素到尾部
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) //链表元素大于阈值
treeifyBin(tab, hash); //转成红黑树
break;
}
//同2。
if (e.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))
break;
p = e;
}
}
//替换value
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}添加到树
//more code here扩容
hashMap的扩容由resize方法实现, 这个resize方法只是简单实现, 不是源码.
private Node<K, V>[] resize() {
int newCap = 0;
//数组为空,初始化一个数组
if (table.length == 0 || table == null){
newCap = DEFAULT_INITIAL_CAPACITY;
Node<K,V>[] newTab = (Node<K,V>[]) new Node[ newCap ];
table = newTab;
return newTab;
}
//数组逻辑长度超过阈值,扩容并复制原数组,数组长度要保证是2的幂次数.
else if (size >= (threshold = (int) (loadFactor * table.length))){
newCap = table.length * 2;
Node<K,V>[] newTab = (Node<K,V>[]) new Node[ newCap ];
transfer(newTab);
table = newTab;
return newTab;
}
//超过最大长度
else if (size > MAXIMUN_CAPACITY){
newCap = HashMap2.MAXIMUN_CAPACITY;
return table;
}
return null;
}
/**
* 把原数组的元素传到扩容后的数组
*/
void transfer(Node[] newTable) {
int newCapacity = newTable.length;
for (Node<K,V> e : table) {
while(null != e) {
Node<K,V> next = e.next;
int i = e.hash & (newCapacity - 1);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
