Java集合面试题

我分析了上百份大中小厂的面经，整理了 Java 面试中最最最常问的一些问题！小伙伴们可以对照着网站里面的文章学习或者准备面试。网站的内容会继续完善，欢迎你在评论区说出你遇到的高频面试题！
林老师带你学编程（「Java 学习+面试指南」是一份涵盖大部分 Java 程序员所需要掌握的核心知识网站，准备 Java 面试，首选《林老师带你学编程》。
Java集合框架的基础接口有哪些?

• Collection为集合层级的根接口。 一个集合代表一组对象，这些对象即为它的元素。 Java平台不提供这 个接口任何直接的实现。
• Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副 牌。
• List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。 List更像长度动态变换 的数组。
• Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。
• 一些其它的接口有Queue 、Dequeue 、SortedSet 、SortedMap和ListIterator。

2.Collection 和 Collections 有什么区别?

• Collection 是一个集合接口，它提供了对集合对象进行基本操作的通用接口方法，所有集合都是它的 子类，比如 List 、Set 等。
• Collections 是一个包装类，包含了很多静态方法，不能被实例化，就像一个工具类，比如提供的排序 方法：Collections. sort(list)。

List、 Set、Map是否继承自Collection接口?
List 、Set 是, Map 不是。 Map是键值对映射容器,与List和Set有明显的区别,而Set存储的零散的元素 且不允许有重复元素(数学中的集合也是如此）, List是线性结构的容器,适用于按数值索引访问元素 的情形。
Collections.sort排序内部原理
在Java 6中Arrays.sort()和Collections.sort()使用的是MergeSort,而在Java 7中,内部实现换成了 TimSort,其对对象间比较的实现要求更加严格。
List、 Set、Map 之间的区别是什么?
List 、Set 、Map 的区别主要体现在两个方面:元素是否有序、是否允许元素重复。
三者之间的区别,如下表:

HashMap 和 Hashtable 有什么区别?
(1）HashMap允许key和value为null,而HashTable不允许。
(2）HashTable是同步的,而HashMap不是。所以HashMap适合单线程环境, HashTable适合多线程 环境。
(3）在Java1.4中引入了LinkedHashMap , HashMap的一个子类,假如你想要遍历顺序,你很容易从 HashMap转向LinkedHashMap,但是HashTable不是这样的,它的顺序是不可预知的。
(4）HashMap提供对key的Set进行遍历,因此它是fail-fast的,但HashTable提供对key的Enumeration 进行遍历,它不支持fail-fast。
(5）HashTable被认为是个遗留的类,如果你寻求在选代的时候修改Map,你应该使用 CocurrentHashMap。
如何决定使用 HashMap 还是 TreeMap?
对于在 Map 中插入、删除、定位一个元素这类操作, HashMap 是最好的选择,因为相对而言HashMap 的插入会更快,但如果你要对一个 key 集合进行有序的遍历,那 TreeMap 是更好的选择。
说一下 HashMap 的实现原理?
HashMap 基于 Hash 算法实现的，我们通过 put(key,value)存储， get(key)来获取。当传入 key 时，HashMap 会根据 key. hashCode() 计算出 hash 值，根据 hash 值将 value 保存在 bucket 里。当计算出 的 hash 值相同时，我们称之为 hash 冲突， HashMap 的做法是用链表和红黑树存储相同 hash 值的value。当 hash 冲突的个数比较少时，使用链表否则使用红黑树。
说一下 HashSet 的实现原理?
HashSet 是基于 HashMap 实现的， HashSet 底层使用 HashMap 来保存所有元素，因此 HashSet 的实 现比较简单，相关 HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成， HashSet 不允许重复的值。
ArrayList 和 LinkedList 的区别是什么?

• 数据结构实现： ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。
• 随机访问效率： ArrayList 比 LinkedList 在随机访问的时候效率要高，因为 LinkedList 是线性的数据 存储方式，所以需要移动指针从前往后依次查找。
• 增加和删除效率：在非首尾的增加和删除操作， LinkedList 要比 ArrayList 效率要高，因为 ArrayList 增删操作要影响数组内的其他数据的下标。

综合来说，在需要频繁读取集合中的元素时，更推荐使用 ArrayList，而在插入和删除操作较多时， 更推荐使用 LinkedList。
为何Map接口不继承Collection接口?
尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此， Map继承 Collection毫无意义，反之亦然。
如果Map继承Collection接口，那么元素去哪儿? Map包含key-value对，它提供抽取key或value列表集 合的方法，但是它不适合“一组对象”规范。
ArrayList和Vector有何异同点?
ArrayList和Vector在很多时候都很类似。
(1）两者都是基于索引的，内部由一个数组支持。
(2）两者维护插入的顺序，我们可以根据插入顺序来获取元素。
(3）ArrayList和Vector的选代器实现都是fail-fast的。
(4）ArrayList和Vector两者允许null值，也可以使用索引值对元素进行随机访问。
以下是ArrayList和Vector的不同点。
(1）Vector是同步的，而ArrayList不是。然而，如果你寻求在选代的时候对列表进行改变，你应该使 用CopyOnWriteArrayList。
(2）ArrayList比Vector快，它因为有同步，不会过载。
(3）ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。
Array 和 ArrayList 有何区别?

• Array 可以存储基本数据类型和对象， ArrayList 只能存储对象。
• Array 是指定固定大小的，而 ArrayList 大小是自动扩展的。
• Array 内置方法没有 ArrayList 多，比如 addAll 、removeAll 、iteration 等方法只有 ArrayList 有。

在 Queue 中 poll()和 remove()有什么区别?
相同点知都是返回第一个元素，并在队列中删除返回的对象。不同点知如果没有元素 poll()会返回 null，而 remove()会直接抛出 NoSuchElementException 异常。
代码示例知
Queue<String> queue = new LinkedList<String>();
queue. offer("string"); // add
System. out. println(queue. poll());
System. out. println(queue. remove());
System. out. println(queue. size());
15.LinkedHashMap有什么特点?
LinkedHashMap是HashMap的一个子类，保存了记录的插入顺序，在用Iterator遍历LinkedHashMap 时，先得到的记录肯定是先插入的，也可以在构造时带参数，按照访问次序排序。
16.HashMap的底层实现原理?(高频问题)
从结构实现来讲， HashMap是数组+链表+红黑树 (JDK1.8增加了红黑树部分）实现的，如下如所示。

这里需要讲明白两个问题：数据底层具体存储的是什么?这样的存储方式有什么优点呢?
(1) 从源码可知， HashMap类中有一个非常重要的字段，就是 Node[] table，即哈希桶数组，明显它是 一个Node的数组。我们来看Node[JDK1.8]是何物。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //⽤来定位数组索引位置
final K key;
V value;
Node<K,V> next; //链表的下⼀个node
Node(int hash, K key, V value, Node<K,V> next) { … }
public final K getKey(){ … }
public final V getValue() { … }
public final String toString() { … }
public final int hashCode() { … }
public final V setValue(V newValue) { … }
public final boolean equals(Object o) { … }
}
Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)。上图中的每个 黑色圆点就是一个Node对象。
(2) HashMap就是使用哈希表来存储的。哈希表为解决冲突，可以采用开放地址法和链地址法等来解决 问题， Java中HashMap采用了链地址法。链地址法，简单来说，就是数组加链表的结合。在每个数组元 素上都一个链表结构，当数据被Hash后，得到数组下标，把数据放在对应下标元素的链表上。例如程序 执行下面代码：
map .put("美团" ,"小美 " );
系统将调用"美团"这个key的hashCode()方法得到其hashCode 值(该方法适用于每个Java对象），然后 再通过Hash算法的后两步运算(高位运算和取模运算，下文有介绍）来定位该键值对的存储位置，有时 两个key会定位到相同的位置，表示发生了Hash碰撞。当然Hash算法计算结果越分散均匀， Hash碰撞 的概率就越小， map的存取效率就会越高。
如果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组数组很小，即使好的Hash 算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈 希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。那么通过什么方式来控制map使得 Hash碰撞的概率又小，哈希桶数组 (Node[] table）占用空间又少呢?答案就是好的Hash算法和扩容机 制。
在理解Hash和扩容流程之前，我们得先了解下HashMap的几个字段。从HashMap的默认构造函数源码 可知，构造函数就是对下面几个字段进行初始化，源码如下：
int threshold; // 所能容纳的key-value对极限
final float loadFactor; // 负载因⼦
int modCount;
int size;
首先， Node[] table的初始化长度length(默认值是16) ，Load factor为负载因子(默认值是0.75)，
threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。threshold = length * Load factor。 也就是说，在数组定义好长度之后，负载因子越大，所能容纳的键值对个数越多。
结合负载因子的定义公式可知， threshold就是在此Load factor和length(数组长度)对应下允许的最大元 素数目，超过这个数目就重新resize(扩容)，扩容后的HashMap容量是之前容量的两倍。默认的负载因 子0.75是对空间和时间效率的一个平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以降低负载因子Load factor的值；相反，如果内存 空间紧张而对时间效率要求不高，可以增加负载因子loadFactor的值，这个值可以大于1。
size这个字段其实很好理解，就是HashMap中实际存在的键值对数量。注意和table的长度length、容纳 最大键值对数量threshold的区别。而modCount字段主要用来记录HashMap内部结构发生变化的次数，主要用于选代的快速失败。强调一点，内部结构发生变化指的是结构发生变化，例如put新键值 对，但是某个key对应的value值被覆盖不属于结构变化。
在HashMap中，哈希桶数组table的长度length大小必须为2的n次方(一定是合数)，这是一种非常规的设 计，常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数，具体证明可以参 考http://blog.csdn.net/liuqiyao_01/article/details/14475159 ，Hashtable初始化桶大小为11，就是桶 大小设计为素数的应用 (Hashtable扩容后不能保证还是素数）。 HashMap采用这种非常规设计，主要 是为了在取模和扩容时做优化，同时为了减少冲突， HashMap定位哈希桶索引位置时，也加入了高位 参与运算的过程。
这里存在一个问题，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况， 一旦出 现拉链过长，则会严重影响HashMap的性能。于是，在JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长(默认超过8）时，链表就转换为红黑树，利用红黑树快速增删 改查的特点提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。
功能实现-方法
HashMap的内部功能实现很多，本文主要从根据key获取哈希桶数组索引位置、 put方法的详细执行、 扩容过程三个具有代表性的点深入展开讲解。
1.确定哈希桶数组索引位置
不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步。前面说过HashMap的 数据结构是数组和链表的结合，所以我们当然希望这个HashMap里面的元素位置尽量分布均匀些，尽 量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道 对应位置的元素就是我们要的，不用遍历链表，大大优化了查询的效率。 HashMap定位数组索引位置，直接决定了hash方法的离散性能。先看看源码的实现(方法一+方法二):
⽅法⼀：
static final int hash(Object key){ //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 为第⼀步 取hashCode值
// h ^ (h >>> 16) 为第⼆步 ⾼位参与运算
return(key==null)?0:(h=key.hashCode())^(h>>>16);
}
⽅法⼆：
static int indexFor(int h,int length){
// jdk1.7的源码，jdk1.8没有这个⽅法，但是实现原理⼀样的
return h&(length-1); //第三步 取模运算
}
这里的Hash算法本质上就是三步： 取key的hashCode值、高位运算、取模运算。
对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用方法一所计算得到的Hash码值 总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比 较均匀的。但是，模运算的消耗还是比较大的，在HashMap中是这样做的：调用方法二来计算该对象 应该保存在table数组的哪个索引处。
这个方法非常巧妙，它通过h & (table.length -1)来得到该对象的保存位，而HashMap底层数组的长度总 是2的n次方，这是HashMap在速度上的优化。当length总是2的n次方时， h& (length-1)运算等价于对 length取模，也就是h%length，但是&比%具有更高的效率。
在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的： (h =k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比 较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。
下面举例说明下， n为table的长度。

2.HashMap的put方法
HashMap的put方法执行过程可以通过下图来理解，自己有兴趣可以去对比源码更清楚地研究学习。

①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；
②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥,如 果table[i]不为空，转向③;
③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④,这里的相同指的是 hashCode以及equals；
④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对， 否则转向⑤;
⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作， 否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。
JDK1.8HashMap的put方法源码如下:
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做处理
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K, V> e;
K k;
// 步骤③：节点key存在，直接覆盖value
if (p.hash == hash &&
19 ((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转换为红⿊树进⾏处理
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// key已经存在直接覆盖value
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;
}
}
++modCount;
// 步骤⑥：超过最⼤容量 就扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
3.扩容机制
扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法 装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自 动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更 多的水，就得换大水桶。
我们分析下resize的源码，鉴于JDK1.8融入了红黑树，较复杂，为了便于理解我们仍然使用JDK1.7的代 码，好理解一些，本质上区别不大，具体区别后文再说。
void resize(int newCapacity) { //传⼊新的容量
Entry[] oldTable = table; //引⽤扩容前的Entry数组
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组⼤⼩如果已经达到最⼤
(2 ^ 30) 了
threshold = Integer.MAX_VALUE; //修改阈值为int的最⼤值(2^31-1)，这样以后就不会扩容了
return;
}


Entry[] newTable = new Entry[newCapacity]; //初始化⼀个新的Entry数组
transfer(newTable); //！！将数据转移到新的Entry数组⾥
table = newTable; //HashMap的table属性引⽤新的Entry数组
threshold = (int) (newCapacity * loadFactor);//修改阈值
}
这里就是使用一个容量更大的数组来代替已有的容量小的数组， transfer()方法将原有Entry数组的元素 拷贝到新的Entry数组里。
void transfer(Entry[] newTable) {
Entry[] src = table; //src引⽤了旧的Entry数组
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
Entry<K, V> e = src[j]; //取得旧Entry数组的每个元素
if (e != null) {
src[j] = null;//释放旧Entry数组的对象引⽤（for循环后，旧的Entry数组不再引⽤任何对象）
do {
Entry<K, V> next = e.next;
int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
e.next = newTable[i]; //标记[1]
newTable[i] = e; //将元素放在数组上
e = next; //访问下⼀个Entry链上的元素
} while (e != null);
}
}
}
newTable[i]的引用赋给了e.next，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链 表的头部位置；这样先放在一个索引上的元素终会被放到Entry链的尾部(如果发生了hash冲突的话），这一点和Jdk1.8有区别，下文详解。在旧数组中同一条Entry链上的元素，通过重新计算索引位置后，有 可能被放到了新数组的不同位置上。
下面举个例子说明下扩容过程。假设了我们的hash算法就是简单的用key mod一下表的大小(也就是数 组的长度）。其中的哈希桶数组table的size=2， 所以key = 3 、7 、5 ，put顺序依次为 5 、7 、3。在mod 2以后都冲突在table[1]这里了。这里假设负载因子 loadFactor=1，即当键值对的实际大小size 大于 table 的实际大小时进行扩容。接下来的三个步骤是哈希桶数组 resize成4，然后所有的Node重新rehash的过 程。

下面我们讲解下JDK1.8做了哪些优化。经过观测可以发现，我们使用的是2次幕的扩展(指长度扩为原来 2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幕的位置。看下图可以明白这句话 的意思， n为table的长度，图 (a）表示扩容前的key1和key2两种key确定索引位置的示例，图 (b）表 示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就 会发生这样的变化:

因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看 看下图为16扩充为32的resize示意图：

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以 认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别， JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新 表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出， JDK1.8不会倒置。有兴趣的同学可 以研究下JDK1.8的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;
}
// 没超过最⼤值，就扩充为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
} 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);
}
// 计算新的resize上限
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) {
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 { // 链表优化重hash的代码块
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;
}
// 原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 原索引放到bucket⾥
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到bucket⾥
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
17.HashMap并发安全的问题
并发的多线程使用场景中使用HashMap可能造成死循环。代码例子如下(便于理解，仍然使用JDK1.7的 环境)：
public class HashMapInfiniteLoop {
private static HashMap<Integer, String> map = new HashMap<Integer, String>
(2，0.75f);


public static void main(String[] args) {
map.put(5， "C");
new Thread("Thread1") {
public void run() {
map.put(7, "B");
System.out.println(map);
}
}.start();
new Thread("Thread2") {
public void run() {
map.put(3, "A);
System.out.println(map);
}
}.start();
}
}
其中， map初始化为一个长度为2的数组， loadFactor=0.75 ，threshold=2*0.75=1，也就是说当put第二 个key的时候， map就需要进行resize。
通过设置断点让线程1和线程2同时debug到transfer方法(3.3小节代码块)的首行。注意此时两个线程已经 成功添加数据。放开thread1的断点至transfer方法的“Entry next = e.next;” 这一行；然后放开线程2的的 断点，让线程2进行resize。结果如下图。

注意， Thread1的 e 指向了key(3)，而next指向了key(7)，其在线程二rehash后，指向了线程二重组后的 链表。
线程一被调度回来执行，先是执行 newTalbe[i] = e， 然后是e = next，导致了e指向了key(7)，而下一次 循环的next = e.next导致了next指向了key(3)。
e.next = newTable[i] 导致 key(3).next 指向了 key(7)。注意：此时的key(7).next 已经指向了key(3)， 环 形链表就这样出现了。

于是，当我们用线程一调用map.get(11)时，悲剧就出现了——Infinite Loop。
JDK1.8与JDK1.7的性能对比
HashMap中，如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话， getKey方法的时间复杂度就是O(1)，如果Hash算法技术的结果碰撞非常多，假如Hash算极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，或者在一个链表中， 或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn) 。 鉴于JDK1.8做了多方面的优化，总体性能优于 JDK1.7，下面我们从两个方面用例子证明这一点。
Hash较均匀的情况为了便于测试，我们先写一个类Key，如下：
class Key implements Comparable<Key> {
private final int value;


Key(int value) {
this.value = value;
}


@Override
public int compareTo(Key o) {
return Integer.compare(this.value, o.value);
}


@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass())
return false;
Key key = (Key) o;
return value == key.value;
}


@Override
public int hashCode() {
return value;
}
}
这个类复写了equals方法，并且提供了相当好的hashCode函数，任何一个值的hashCode都不会相同， 因为直接使用value当做hashcode。为了避免频繁的GC，我将不变的Key实例缓存了起来，而不是一遍 一遍的创建它们。代码如下：
public class Keys {
public static final int MAX_KEY = 10_000_000;
private static final Key[] KEYS_CACHE = new Key[MAX_KEY];


static {
for (int i = 0; i < MAX_KEY; ++i) {
KEYS_CACHE[i] = new Key(i);
}
}


public static Key of(int value) {
return KEYS_CACHE[value];
}
}
现在开始我们的试验，测试需要做的仅仅是，创建不同size的HashMap (1、10 、100 、 …… 10000000)，屏蔽了扩容的情况，代码如下：
static void test(int mapSize) {
HashMap<Key, Integer> map = new HashMap<Key, Integer>(mapSize);
for (int i = 0; i < mapSize; ++i) {
map.put(Keys.of(i), i);
}
long beginTime = System.nanoTime(); //获取纳秒
for (int i = 0; i < mapSize; i++) {
map.get(Keys.of(i));
}
long endTime = System.nanoTime();
System.out.println(endTime - beginTime);
}


public static void main(String[] args) {
for (int i = 10; i <= 1000 0000;
i *= 10){
test(i);
}
}
在测试中会查找不同的值，然后度量花费的时间，为了计算getKey的平均时间，我们遍历所有的get方 法，计算总的时间，除以key的数量，计算一个平均值，主要用来比较，绝对值可能会受很多环境因素 的影响。结果如下：

通过观测测试结果可知， JDK1.8的性能要高于JDK1.7 15%以上，在某些size的区域上，甚至高于100%。 由于Hash算法较均匀， JDK1.8引入的红黑树效果不明显，下面我们看看Hash不均匀的的情况。
Hash极不均匀的情况假设我们又一个非常差的Key，它们所有的实例都返回相同的hashCode值。这是使用HashMap最坏的 情况。代码修改如下：
class Key implements Comparable<Key> {
//…
@Override
public int hashCode() {
return 1;
}
}
仍然执行main方法，得出的结果如下表所示：

从表中结果中可知，随着size的变大， JDK1.7的花费时间是增长的趋势，而JDK1.8是明显的降低趋势， 并且呈现对数增长稳定。当一个链表太长的时候， HashMap会动态的将它替换成一个红黑树，这话的 话会将时间复杂度从O(n)降为O(logn) 。hash算法均匀和不均匀所花费的时间明显也不相同，这两种情 况的相对比较，可以说明一个好的hash算法的重要性。
测试环境：处理器为2.2 GHz Intel Core i7，内存为16 GB 1600 MHz DDR3 ，SSD硬盘，使用默认的 JVM参数，运行在64位的OS X 10.10.1上。
HashMap操作注意事项以及优化?
(1) 扩容是一个特别耗性能的操作，所以当程序员在使用HashMap的时候，估算map的大小，初始化的 时候给一个大致的数值，避免map进行频繁的扩容。
(2) 负载因子是可以修改的，也可以大于1，但是建议不要轻易修改，除非情况非常特殊。
(3) HashMap是线程不安全的，不要在并发的环境中同时操作HashMap，建议使用
ConcurrentHashMap。
(4) JDK1.8引入红黑树大程度优化了HashMap的性能。
(5) 还没升级JDK1.8的，现在开始升级吧。 HashMap的性能提升仅仅是JDK1.8的冰山一角。
林老师带你学编程（「Java 学习+面试指南」是一份涵盖大部分 Java 程序员所需要掌握的核心知识网站，准备 Java 面试，首选《林老师带你学编程！）。