1.HashMap的实现原理
HashMap基于哈希原理，当添加一个元素（key-value）时，调用键对象key的hashCode()方法来计算hashcode，以此确定插入数组的位置（桶的位置），但是可能存在同一hashcode值的元素已经被放在数组同一位置了，这时便产生了碰撞。当发生碰撞后，将其添加到同一hashcode的元素的后面，它们在数组的同一位置，但是形成了链表，同一各链表上的hashcode值是相同的。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。
/**
* 数组元素Node<K,V>实现了Entry接口
*/
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;
}
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
2.成员变量
/**
*初始容量，也就是默认会创建 16 个箱子，箱子的个数不能太多或太少。如果太少，很容易触发扩容，如果
*太多，遍历哈希表会比较慢。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
*哈希表最大容量，一般情况下只要内存够用，哈希表不会出现问题。
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
*默认的负载因子。因此初始情况下，当键值对的数量大于 16 * 0.75 = 12 时，就会触发扩容。
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 如果哈希函数不合理，即使扩容也无法减少箱子中链表的长度，因此 Java 的处理方案是当链表太长时，转
*换成红黑树。这个值表示当某个箱子中，链表长度大于 8 时，有可能会转化成树。
*/
static final int TREEIFY_THRESHOLD = 8;
/**
*在哈希表扩容时，如果发现链表长度小于 6，则会由树重新退化为链表。
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
*在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。这是为了避免在哈希表建立初
*期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 桶数组
*/
transient Node<K,V>[] table;
/**
* 保存缓存的entrySet
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* Map集合所包含的数据个数
*/
transient int size;3.成员方法
1>根据key获取value值
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab;//Entry对象数组
Node<K,V> first,e; //在tab数组中经过散列的第一个位置
int n;
K k;
/*找到插入的第一个Node，方法是hash值和n-1相与，tab[(n - 1) & hash]*/
//也就是说在一条链上的hash值相同的
if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {
/*检查第一个Node是不是要找的Node*/
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))//判断条件是hash值要相同，key值要相同
return first;
/*检查first后面的node*/
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
/*遍历后面的链表，找到key值和hash值都相同的Node*/
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
实现原理：<1>根据key获取对于的hash值
<2>在table数组不为空的情况下，判断first=tab[hash&(n-1)]是否存在，
如果存在，则判断first.key是否等于参数key，相等的话则当前结点first就是所要查找的结点，不等就遍历后面的链 表找到相同的key值返回对应的Value值即可
如果不存在，则返回null
2>新增map
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab;
Node<K,V> p;
int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/*如果table的在（n-1）&hash的值是空，就新建一个节点插入在该位置*/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
/*表示有冲突,开始处理冲突*/
else {
Node<K,V> e;
K k;
/*检查第一个Node，p是不是要找的值*/
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
/*指针为空就挂在后面*/
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果冲突的节点数已经达到8个，看是否需要改变冲突节点的存储结构，
//treeifyBin首先判断当前hashMap的长度，如果不足64，只进行
//resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
/*如果有相同的key值就结束遍历*/
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
/*就是链表上有相同的key值*/
if (e != null) { // existing mapping for key，就是key的Value存在
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;//返回存在的Value值
}
}
++modCount;
/*如果当前大小大于门限，门限原本是初始容量*0.75*/
if (++size > threshold)
resize();//扩容两倍
afterNodeInsertion(evict);
return null;
}
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
......
}实现原理：<1>判断键值对数组tab[]是否为空或为null，否则以默认大小resize()；
<2>根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加，否则转入3
<3>判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理
3>扩容机制
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
* 空参构造函数(使用默认初始table容量16和默认加载因子0.75)
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
*
* @param initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
* 指定初始容量的构造函数(默认加载因子0.75)
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 指定初始容量和加载因子的构造函数
*/
public HashMap(int initialCapacity, float loadFactor) {
/**
* 初始容量不能小于0
*/
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
/**
* 判断初始容量参数值如果大于最大哈希桶容量（即：数组长度）,则将该参数值改为最大哈希桶容
*量值
*/
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
/**
* 加载因子不能小于等于0并且是浮点值
*/
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
/**
* 通过初始容量参数值计算HashMap的元素存储阀值
*/
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 保证指定的设置的table数组的长度必须是2的n次方，如果你传入的不是2的n次方，
* 那么经过这个方法出来的值一般都是大于你传入的参数最接近的2的n次方
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
/**
* 传入Map类的参数的构造函数，将参数map里的所有元素加入HashMap表中
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//获取要插入map的大小
int s = m.size();
if (s > 0) {
if (table == null) { // 当前表为空
//根据m的元素数量和当前表的加载因子，计算出阈值
float ft = ((float)s / loadFactor) + 1.0F;
//修正阈值的边界 不能超过MAXIMUM_CAPACITY
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//如果新的阈值大于当前阈值
if (t > threshold)
//返回一个 >=t的 满足2的n次方的阈值
threshold = tableSizeFor(t);
}
else if (s > threshold)//如果当前元素表不是空的，但是 m的元素数量大于阈值，说明一定要扩容。
resize();
//遍历 m 依次将元素加入当前表中。
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
/**
* 初始化或者加倍表的容量，如果当前表的容量为null，那么根据当前阀值初始化容量，否则，
* 使用二次幂扩展法，在新表中，每个哈希桶的元素要么保持相同的索引，要么以两个偏移的幂移动
*/
final Node<K,V>[] resize() {
//oldTab为当前表的哈希桶
Node<K,V>[] oldTab = table;
//当前哈希桶的容量(长度)
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//当前的阀值
int oldThr = threshold;
//定义新的哈希桶的长度、新的阀值
int newCap, newThr = 0;
if (oldCap > 0) {//如果当前哈希桶的容器(长度)大于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; // 变为原来的两倍，向左位移1位，如：00000001向左位移1位变成00000010
}
else if (oldThr > 0) // 如果当前表是空的，但是有阀值
newCap = oldThr;//那么新表的容量就等于旧的阀值
else { // 使用默认值零初始化阀值
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) {
//取出当前的节点 e
Node<K,V> e;
//如果当前桶中有元素,则将链表赋值给e
if ((e = oldTab[j]) != null) {
//将原哈希桶置空以便GC
oldTab[j] = null;
//如果当前链表中就一个元素，（没有发生哈希碰撞）
if (e.next == null)
//直接将这个元素放置在新的哈希桶里。
//注意这里取下标 是用 哈希值 与 桶的长度-1 。 由于桶的长度是2的n次方，这么做其实是等于 一个模运算。但是效率更高
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)如果发生过哈希碰撞 ,而且是节点数超过8个，转化成了红黑树
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
/**如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。
* 因为扩容使容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，
* 即high位。
*/
//低位链表的头结点、尾节点
Node<K,V> loHead = null, loTail = null;
//高位链表的头节点、尾节点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;//临时节点 存放e的下一个节点
do {
next = e.next;
/**
* table的大小一直是2的倍数，2的N次方，因此当前元素插入table的索引的值为其hash值的后N位组成的值,
* 那么扩容后的table大小即为2的N+1次方，则其中元素的table索引为其hash值的后N+1位确定，比原来多了一位
* 因此，table中的元素只有两种情况：
* 1.元素hash值第N+1位为0：不需要进行位置调整
* 2.元素hash值第N+1位为1：调整至原索引的两倍位置
*/
// 判断即用于确定元素hash值第N+1位是否为0,若为0，则使用loHead与loTail，将元素移至新table的原索引处
if ((e.hash & oldCap) == 0) {
//给头尾节点指针赋值
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {//若不为0，则使用hiHead与hiHead，将元素移至新table的两倍索引处
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}//循环直到链表结束
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}//将高位链表存放在新index处
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
实现原理：<1>当前数组长度不为0时，
如果大于最大容量，则阀值取整型类的最大值，返回当前数组；
如果初始容量 <= 当前数组长度 < 最大容量，则新数组容量为原来的两倍，新阈值也为原来的两倍。
<2> 当前阈值不为0时，数组长度等于阈值大小；
<3>其余情况下，新数组容量等于初始默认容量，新数组阈值等于初始默认容量 *影响因子；
<4>经过上述三步的计算，如果新阈值为0的话则需要使用新数组容量 *影响因子得到新阈值的大小，并进行越界判断；
<5>更新全局变量threshold，更新全局变量table；
<6>将当前数组中的所有节点转移到新数组中,判断当前节点的next是否存在，
若存在则判断当前节点是否为TreeNode类型，若是的话就代表当前hashcode所包含的节点数量大于8，需要进行 红黑树的构建；若不存在则按照链表的构建方式，构建后续节点。
若不存在则插入到新数组中即可。
4.扩展问题
1>如果HashMap对象中的key是对象该怎么处理？
例如：Student st1 = new Student("Erica",1,100)；
Student st2 = new Student("Erica",1,100)；
我们希望key为学生，value为该学生的成绩。st1和st2为同一人，则肯定为一条数据，但是实际却是两条数据，如下所示：
public class Student{
private String name;
private int age;
private float score;
public Student() {
}
public Student(String name, int age, float score) {
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
}
public static void main(String[] args) {
Student modelA = new Student ("Erica",1,100);
Student modelB = new Student ("Erica",1,100);
System.out.println(modelA.hashCode()); //21029277
System.out.println(modelB.hashCode()); //24324022
System.out.println(modelA.equals(modelB)); // false
Map<CustomKeyModel,Float> map = new HashMap<CustomKeyModel, Float>();
map.put(modelA,modelA.getScore());
map.put(modelB,modelB.getScore());
System.out.println(map.size()); // 2
System.out.println(map.get(modelA)); // 100.0
System.out.println(map.get(modelB)); // 100.0
System.out.println(map.get(modelA).equals(map.get(modelB)));// true
}问题原因：因为hashCode()和equals()方法均继承于Object类，每个对象的hashCode值均不相等，而且在equals()方法中比较的是对象的地址，所以st1和st2指的便是两个对象，源码如下：
public native int hashCode();
public boolean equals(Object obj) {
return (this == obj);
}解决方法：通过分析HashMap的put方法和get方法，均是先比较hashCode的取值，hashCode相同的情况下再去比较key的取值，因此需要将hashCode()方法和equals()方法进行重写。
package model;
public class Student{
private String name;
private int age;
private float score;
public Student() {
}
public Student(String name, int age, float score) {
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
@Override
public int hashCode() {
return this.name.hashCode() + this.age;
}
@Override
public boolean equals(Object obj) {
return obj instanceof CustomKeyModel && this.name.equals(((CustomKeyModel) obj).name)
&& this.age == ((CustomKeyModel) obj).age;
}
}
public static void main(String[] args) {
Student modelA = new Student ("Erica",1,100);
Student modelB = new Student ("Erica",1,100);
System.out.println(modelA.hashCode()); //67223195
System.out.println(modelB.hashCode()); //67223195
System.out.println(modelA.equals(modelB)); // true
Map<CustomKeyModel,Float> map = new HashMap<CustomKeyModel, Float>();
map.put(modelA,modelA.getScore());
map.put(modelB,modelB.getScore());
System.out.println(map.size()); // 1
System.out.println(map.get(modelA)); // 100.0
System.out.println(map.get(modelB)); // 100.0
System.out.println(map.get(modelA).equals(map.get(modelB)));// true
}
2>HashMap的加载因子为什么是0.75？
答：提高空间利用率和 减少查询成本的折中，在理想情况下,使用随机哈希码,节点出现的频率在hash桶中遵循泊松分布，0.75的话碰撞最小，
HashMap有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动扩容之前可以达到多满的一种度量。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行扩容、rehash操作（即重建内部数据结构），扩容后的哈希表将具有两倍的原容量。
通常，加载因子需要在时间和空间成本上寻求一种折衷。
加载因子过高，例如为1，虽然减少了空间开销，提高了空间利用率，但同时也增加了查询时间成本；
加载因子过低，例如0.5，虽然可以减少查询时间成本，但是空间利用率很低，同时提高了rehash操作的次数。
在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少rehash操作次数，所以，一般在使用HashMap时建议根据预估值设置初始容量，减少扩容操作。
选择0.75作为默认的加载因子，完全是时间和空间成本上寻求的一种折衷选择，
3>HashMap的默认初始化长度为什么是16
答：因为在使用不是2的幂的数字的时候，Length-1的值是所有二进制位全为1，这种情况下，index的结果等同于HashCode后几位的值。只要输入的HashCode本身分布均匀，Hash算法的结果就是均匀的。这是为了实现均匀分布。
4>hashmap为什么线程不安全
答：HashMap在put的时候，插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是rehash，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash值相同，可能出现同时在同一数组下用链表表示，造成闭环，导致在get时会出现死循环，所以HashMap是线程不安全的。
参考：解析为什么hashmap是线程不安全的？_心肝宝贝甜蜜饯儿的博客-CSDN博客_hashmap线程不安全的原因
举个例子来看一下吧，
在扩容后需要将原数组的元素，放置到新的位置上，具体代码如下：
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;//第一行
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);//第二行
e.next = newTable[i];//第三行
newTable[i] = e;//第四行
e = next;//第五行
}
}
}
4-1.单线程的情况下
4-2.多线程的情况下
从4-1单线程示例下，假设t2线程执行完成，则此时的数组如下：
t1线程被唤醒，
当获取某个元素的时候，是需要遍历链表的，这个时候就会出现死循环，
697
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
