问？什么时候用HashMap?特点?
基于Map接口的实现，存储键值对时，它可以接收null的键值，是非同步的，HashMap存储着Entry(hash, key, value, next)对象。
问？HashMap的工作原理？
通过 hash 的方法，采用put 和 get 存储和获取对象。存储对象时，我们将K/V传给put方法时，它调用hashCode计算hash从而得到 bucket 位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量(超过Load Facotr 则 resize 为原来的2倍)。获取对象时，我们将 K 传给 get ，它调用 hashCodeO() 计算 hash 从而得到 bucket 位置，并进一步调用 equals() 方法确定键值对。如果发生碰撞的时候，Hashmap通过链表将产生碰撞冲突的元素组织起来，在Java 8中，如果一个 bucket 中碰撞冲突的元素超过某个限制(默认是8)，则使用红黑树来替换链表，从而提高速度。
问？知道get和put的原理吗？equals()和hashCode()的都有什么作用？
通过对 key 的
hashCode()进行hashing，并计算下标( (n-1) & hash )，从而获得 buckets 的位置。如果产生碰撞，则利用key.equals()方法去链表或树中去查找对应的节点
问？你知道hash的实现吗？为什么要这样实现？
在Java 1.8的实现中，是通过 hashCode() 的高 16 位异或低 16 位实现的：(h =k.hashCode()) ^ (h >>> 16) ，主要是从速度、功效、质量来考虑的，这么做可以在 bucket 的 n 比较小的时候，也能保证考虑到高低 bit 都参与到 hash 的计算中，同时不会有太大的开销。
问？如果HashMap的大小超过了负载因子( load factor )定义的容量，怎么办？
如果超过了负载因子(默认0.75)，则会重新 resize 一个原来长度两倍的HashMap，并且重新调用 hash 方法。
问？为什么 capcity 是2的幂？
因为 算 index 时用的是
(n-1) & hash，这样就能保证n-1是全为1的二进制数，如果不全为1的话，存在某一位为0，那么0，1与0与的结果都是0，这样便有可能将两个hash不同的值最终装入同一个桶中，造成冲突。所以必须是2的幂
相关概念
- 数组：数组指的是一组相关类型的变量集合，变量彼此之间没有任何关联（特点：存储区间连续，占用内存严重，数组有下标，查询数据快，但是增删比较慢）
- 链表：一种常见的基础数据结构，是一种线性表，但是不会按照线性的顺序存储数据，而是每一个节点里存到下一个节点的指针。存储区间离散，占用内存比较宽松，使用链表查询比较慢，但是增删比较快；
- 哈希表：Hash table 既满足了数据的快速查询（根据关键码值key value 而直接进行访问的数据结构），也不会占用太多的内存空间，十分方便。哈希表是数组加链表组成。
- 容量（Capacity）：Capacity 就是 bucket 的大小
- 负载因子（Load factor）：Load factor就是 bucket 填满程度的最大比例
- 注意！！！-------如果对迭代性能要求很高的话，不要把 capacity 设置过大，也不要把 load factor 设置过小。当bucket中的entries的数目大于capacity*load factor 时，就需要调整 bucket 的大小为当前的2倍。
问？HashMap结构及原理
1）HashMap结构
HashMap 是基于Hash表的Map 接口的非同步实现，实现HashMap对数据的操作，允许有一个null键，多个null值,HashMap底层就是一个数组结构，数组中的每一项又是一个链表。数组+链表结构，新建一个HashMap的时候，就会初始化一个数组。Entry就是数组中的元素，每个Entry其实就是一个key-value的键值对,它持有一个指向下一个元素的引用，这就构成了链表，HashMap底层将key-value当成一个整体来处理，这个整体就是一个Entry对象。HashMap底层采用一个Entry【】数组来保存所有的key-value键值对，当需要存储一个Entry对象时，会根据hash算法来决定在其数组中的位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry对象时，也会根据hash算法找到其在数组中的存储位置， 在根据equals方法从该位置上的链表中取出Entry
2）HashMap的存储
HashMap的put()&get()方法
put：（key-value）方法是HashMap中最重要的方法，使用HashMap最主要使用的就是put，get两个方法。
- 判断键值对数组table[i]是否为空或者为null，否则执行resize（）进行扩容；
- 根据键值key计算hash值得到插入的数组索引 i ,如果table[i] == null ，直接新建节点添加即可，转入6，如果table[i] 不为空，则转向3；
- 判断table[i] 的首个元素是否和key一样，如果相同（hashCode和equals）直接覆盖value，否则转向4；
- 判断table[i] 是否为treeNode，即table[i]是否为红黑树，如果是红黑树，则直接插入键值对，否则转向5；
- 遍历table[i] ,判断链表长度是否大于8，大于8的话把链表转换成红黑树，进行插入操作，否则进行链表插入操作；便利时遇到相同key直接覆盖value；
- 插入成功后，判断实际存在的键值对数量size是否超过了threshold，如果超过，则扩容；
//注意是JDK1.8
public V put(K key, V value) {
//对key的hashCode()做hash
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node<K,V>[] tab;
Node<K,V> p;
int n, i;
// tab为空则创建
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 计算index，并对null做处理，index 的计算 i = (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;
// 这个位置有节点，且与新节点相同，进行覆盖
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 这个位置有节点，且节点类型为 TreeNode
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);
// 检测是否该从链表变成树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 写入
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 超过load factor*current capacity，resize
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
get方法取值过程：
int hash = key.hashCode（）；
int index = hash%Entry[].length;
- 指定key通过hash函数得到key的hash值；
- 调用内部方法getNode（），得到桶号（一般为hash值对桶数求摸）；
- 比较桶的内部元素是否和key相等，如不相等，则没有找到，相等，则取出相等记录的value；
- 如果得到key所在桶的头结点恰好是红黑树节点，就调用红黑树节点的getTreeNode（）方法，否则就遍历链表节点。getTreeNode（）方法通过调用树形节点的find（）方法进行查找。由于之前添加时已经保证这个树是有序的，因此查找时基本就是折半查找，效率高；
- 如果对比节点的哈希值和要查找的哈希值相等，就会判断key是否相等，相等就直接返回；不相等就从子树中递归查找；
HashMap中直接地址用hash函数生成，冲突用比较函数解决。如果每个桶内部只有一个元素，那么查找的时候只有一次比较。当许多桶内没有值得时候，许多查询就会更快
问？了解addEntry方法吗？
- 添加新元素前，判断是否需要对map的数组进行扩容，如果需要扩容，则扩容多大？
- 对于新增key-value键值对，如果可以的hash值相同，则构造单向列表；
注意！！！-----jdk1.8
final Node<K,V>[] resize() {
//olaTab当前表的hash桶
Node<K,V>[] oldTab = table;
//lenth 容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//oldThr 当前的阈值
int oldThr = threshold;
// 初始化新的容量（newCap）和阈值(newThr)为0
int newCap, newThr = 0;
if (oldCap > 0) {
//判断超过最大值，就不再去扩充了，任你去碰撞吧
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果没有超过最大值，则进行扩充，扩充为原来2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//如果旧的容量大于等于默认初始容量16,那么新的阈值也等于旧的阈值的两倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;//新表的容量就等于旧的阈值
else { // zero initial threshold signifies using defaults
//新表的容量为默认的容量 16
newCap = DEFAULT_INITIAL_CAPACITY;
//新的阈值为默认容量16 * 默认加载因子0.75f = 12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值是0，对应的是 当前表是空的，但是有阈值的情况
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) {
//把每个 bucket 都移动到新的 buckets 中
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;
//如果发生过哈希碰撞 ,而且是节点数超过8个，转化成了红黑树
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置
else { // preserve order
//因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量
//低位链表的头结点、尾节点
Node<K,V> loHead = null, loTail = null;
//高位链表的头节点、尾节点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;//临时节点 存放e的下一个节点
do {
next = e.next;
//这里又是一个利用位运算 代替常规运算的高效点： 利用哈希值 与 旧的容量，可以得到哈希值去模后，是大于等于oldCap还是小于oldCap，等于0代表小于oldCap，应该存放在低位，否则存放在高位
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);
//将低位链表存放在原index处，
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//将高位链表存放在新index处
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
问？JDK8有啥变化？
相比于JDK7，JDK8中的HashMap会将较长的链表转为红黑树，这也是与JDK7的核心差异
- JDK 8 为红黑树 + 链表 + 数组的形式，当桶内元素大于8时，便会树化
- hash 值的计算方式不同(jdk 8 简化)
- 1.7 table在创建hashmap时分配空间，而1.8在put的时候分配，如果table为空，则为table分配空间。
- 在发生冲突，插入链中时，7是头插法，8是尾插法。
- 在resize操作中，7需要重新进行index的计算，而8不需要，通过判断相应的位是0还是1，要么依旧是原index，要么是oldCap + 原index
问？怎么扩容？
扩容必须满足两个条件
存放新值的时候当前已有元素必须大于阈值；
存放新值的时候当前存放数据发生hash碰撞（当前key计算的hash值计算出的数组索引位置已经存在值）
HashMap在添加值的时候，它默认能存储16个键值对，直到你使用这个HashMap时，它才会给HashMap分配16个键值对的存储空间，（负载因子为0.75,阈值为12），当16个键值对已经存储满了，我们在添加第17个键值对的时候才会发生扩容现象，因为前16个值，每个值在底层数组中分别占据一个位置，并没有发生hash碰撞。
HashMap也有可能存储更多的键值对，最多可以存储26个键值对，我们来算一下：存储的前11个值全部发生hash碰撞，存到数组的同一个位置中，（这时元素个数小于阈值12，不会扩容），之后存入15个值全部分散到数组剩下的15个位置中，（这时元素个数大于等于阈值，但是每次存入元素并没有发生hash碰撞，不会扩容），11+15=26，当我们存入第27个值得时候满足以上两个条件，HashMap才会发生扩容；
问？线程安全吗？
HashMap是线程不安全的
问？不安全怎么办？
方法一:通过Collections.synchronizedMap()返回一个新的Map,这个新的map就是线程安全的.
方法二:重新改写了HashMap,具体的可以查看java.util.concurrent.ConcurrentHashMap.
两者对比：
1)实现原理
方法一原理:
通过Collections.synchronizedMap()来封装所有不安全的HashMap的方法,就连toString, hashCode都进行了封装. 封装的关键点有2处,
1)使用了经典的synchronized来进行互斥,
2)使用了代理模式new了一个新的类,这个类同样实现了Map接口.
方法二原理:
重新写了HashMap,比较大的改变有如下几点.
使用了新的锁机制(可以理解为乐观锁)稍后详细介绍
把HashMap进行了拆分,拆分成了多个独立的块,这样在高并发的情况下减少了锁冲突的可能
2)锁机制的不同
方法一使用的是的synchronized方法,是一种悲观锁.在进入之前需要获得锁,确保独享当前对象,然后做相应的修改/读取.
方法二使用的是乐观锁,只有在需要修改对象时,比较和之前的值是否被人修改了,如果被其他线程修改了,那么就会返回失败.锁的实现,使用的是NonfairSync. 这个特性要确保修改的原子性,互斥性,无法在JDK这个级别得到解决,JDK在此次需要调用JNI方法,而JNI则调用CAS指令来确保原子性与互斥性.读者可以自行Google JAVA CAS来了解更多. JAVA的乐观锁是如何实现的.当如果多个线程恰好操作到ConcurrentHashMap同一个segment上面,那么只会有一个线程得到运行,其他的线程会被LockSupport.park(),稍后执行完成后,会自动挑选一个线程来执行LockSupport.unpark().
3)如何得到/释放锁
得到锁:
方法一:在Hashmap上面,synchronized锁住的是对象(不是Class),所以第一个申请的得到锁,其他线程将进入阻塞,等待唤醒.
方法二:检查AbstractQueuedSynchronizer.state,如果为0,则得到锁,或者申请者已经得到锁,则也能再辞得到锁,并且state也加1.
释放锁:
都是得到锁的逆操作,并且使用正确,二种方法都是自动选取一个队列中的线程得到锁可以获得CPU资源.
4)优缺点
方法一:
优点:代码实现十分简单,一看就懂.
缺点:从锁的角度来看,方法一直接使用了锁住方法,基本上是锁住了尽可能大的代码块.性能会比较差.
方法二:
优点:需要互斥的代码段比较少,性能会比较好. ConcurrentHashMap把整个Map切分成了多个块,发生锁碰撞的几率大大降低,性能会比较好.
缺点:代码实现稍稍复杂些.
七、项目中怎么用？
自由发挥
150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
