2.ArrayList和LinkedList有什么区别？
（1）数据结构不同
ArrayList基于数组实现
LinkedList基于双向链表实现
（2） 多数情况下，ArrayList更利于查找，LinkedList更利于增删
ArrayList基于数组实现，get(int index)可以直接通过数组下标获取，时间复杂度是O(1)；
LinkedList基于链表实现，get(int index)需要遍历链表，时间复杂度是O(n)；当然，get(E
element)这种查找，两种集合都需要遍历，时间复杂度都是O(n)。
ArrayList增删如果是数组末尾的位置，直接插⼊或者删除就可以了，但是如果插⼊中间的
位置，就需要把插⼊位置后的元素都向前或者向后移动，甚⾄还有可能触发扩容；双向链
表的插⼊和删除只需要改变前驱节点、后继节点和插⼊节点的指向就⾏了，不需要移动元
素。
注意，这个地⽅可能会出陷阱，LinkedList更利于增删更多是体现在平均步长上，不是体
现在时间复杂度上，⼆者增删的时间复杂度都是O(n)
（3）是否⽀持随机访问
ArrayList基于数组，所以它可以根据下标查找，⽀持随机访问，当然，它也实现了
RandmoAccess 接⼜，这个接⼜只是⽤来标识是否⽀持随机访问。
LinkedList基于链表，所以它没法根据序号直接获取元素，它没有实现RandmoAccess 接
⼜，标记不⽀持随机访问。
（4）内存占⽤，ArrayList基于数组，是⼀块连续的内存空间，LinkedList基于链表，内存空
间不连续，它们在空间占⽤上都有⼀些额外的消耗：
ArrayList是预先定义好的数组，可能会有空的内存空间，存在⼀定空间浪费
LinkedList每个节点，需要存储前驱和后继，所以每个节点会占⽤更多的空间
3.ArrayList的扩容机制了解吗？
ArrayList是基于数组的集合，数组的容量是在定义的时候确定的，如果数组满了，再插⼊，
就会数组溢出。所以在插⼊时候，会先检查是否需要扩容，如果当前容量+1超过数组长度，
就会进⾏扩容。
ArrayList的扩容是创建⼀个1.5倍的新数组，然后把原数组的值拷贝过去。
4.ArrayList怎么序列化的知道吗？ 为什么⽤transient修饰数组？
ArrayList的序列化不太⼀样，它使⽤ transient 修饰存储元素的 elementData 的数
组， transient 关键字的作⽤是让被修饰的成员属性不被序列化。
为什么最ArrayList不直接序列化元素数组呢？
出于效率的考虑，数组可能长度100，但实际只⽤了50，剩下的50不⽤其实不⽤序列化，这样
可以提⾼序列化和反序列化的效率，还可以节省内存空间。
那ArrayList怎么序列化呢？
ArrayList通过两个⽅法readObject、writeObject⾃定义序列化和反序列化策略，实际直接使
⽤两个流 ObjectOutputStream 和 ObjectInputStream 来进⾏序列化和反序列化。
5.快速失败(fail-fast)和安全失败(fail-safe)了解吗？
快速失败（fail—fast）：快速失败是Java集合的⼀种错误检测机制
在⽤迭代器遍历⼀个集合对象时，如果线程A遍历过程中，线程B对集合对象的内容进⾏
了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。
原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使⽤⼀个 modCount
变量。集合在被遍历期间如果内容发⽣变化，就会改变 modCount 的值。每当迭代器使⽤
hashNext()/next()遍历下⼀个元素之前，都会检测modCount变量是否为expectedmodCount
值，是的话就返回遍历；否则抛出异常，终⽌遍历。
注意：这⾥异常的抛出条件是检测到 modCount！=expectedmodCount 这个条件。如果集
合发⽣变化时修改modCount值刚好又设置为了expectedmodCount值，则异常不会抛出。因
此，不能依赖于这个异常是否抛出⽽进⾏并发操作的编程，这个异常只建议⽤于检测并发
修改的bug。
场景：java.util包下的集合类都是快速失败的，不能在多线程下发⽣并发修改（迭代过程
中被修改），⽐如ArrayList 类。
安全失败（fail—safe）
采⽤安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，⽽是先复制原有
集合内容，在拷贝的集合上进⾏遍历。
原理：由于迭代时是对原集合的拷贝进⾏遍历，所以在遍历过程中对原集合所作的修改并
不能被迭代器检测到，所以不会触发Concurrent Modification Exception。
缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代
器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那⼀刻拿到的集合拷贝，在
遍历期间原集合发⽣的修改迭代器是不知道的。
场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使⽤，并发修
改，⽐如CopyOnWriteArrayList类。
6.有哪⼏种实现ArrayList线程安全的⽅法？
fail-fast是⼀种可能触发的机制，实际上，ArrayList的线程安全仍然没有保证，⼀般，保证
ArrayList的线程安全可以通过这些⽅案：
使⽤ Vector 代替 ArrayList。（不推荐，Vector是⼀个历史遗留类）
使⽤ Collections.synchronizedList 包装 ArrayList，然后操作包装后的 list。
使⽤ CopyOnWriteArrayList 代替 ArrayList。
在使⽤ ArrayList 时，应⽤程序通过同步机制去控制 ArrayList 的读写。
7.CopyOnWriteArrayList了解多少？
CopyOnWriteArrayList就是线程安全版本的ArrayList。
它的名字叫 CopyOnWrite ——写时复制，已经明⽰了它的原理。
CopyOnWriteArrayList采⽤了⼀种读写分离的并发策略。CopyOnWriteArrayList容器允许并发
读，读操作是⽆锁的，性能较⾼。⾄于写操作，⽐如向容器中添加⼀个元素，则⾸先将当前
容器复制⼀份，然后在新副本上执⾏写操作，结束之后再将原容器的引⽤指向新容器。
Map
Map中，毫⽆疑问，最重要的就是HashMap，⾯试基本被盘出包浆了，各种问法，⼀定要好好
准备。
8.能说⼀下HashMap的数据结构吗？
JDK1.7的数据结构是 数组 + 链表 ，JDK1.7还有⼈在⽤？不会吧……
说⼀下JDK1.8的数据结构吧：
JDK1.8的数据结构是 数组 + 链表 + 红⿊树 。
数据结构⽰意图如下：
其中，桶数组是⽤来存储数据元素，链表是⽤来解决冲突，红⿊树是为了提⾼查询的效率。
数据元素通过映射关系，也就是散列函数，映射到桶数组对应索引的位置
如果发⽣冲突，从冲突的位置拉⼀个链表，插⼊冲突的元素
如果链表长度>8&数组⼤⼩>=64，链表转为红⿊树
如果红⿊树节点个数<6 ，转为链表
9.你对红⿊树了解多少？为什么不⽤⼆叉树/平衡树呢？
红⿊树本质上是⼀种⼆叉查找树，为了保持平衡，它又在⼆叉查找树的基础上增加了⼀些规
则：
1. 每个节点要么是红⾊，要么是⿊⾊；
2. 根节点永远是⿊⾊的；
3. 所有的叶⼦节点都是是⿊⾊的（注意这⾥说叶⼦节点其实是图中的 NULL 节点）；
4. 每个红⾊节点的两个⼦节点⼀定都是⿊⾊；
5. 从任⼀节点到其⼦树中每个叶⼦节点的路径都包含相同数量的⿊⾊节点；
之所以不⽤⼆叉树：
红⿊树是⼀种平衡的⼆叉树，插⼊、删除、查找的最坏时间复杂度都为 O(logn)，避免了⼆叉
树最坏情况下的O(n)时间复杂度。
之所以不⽤平衡⼆叉树：
平衡⼆叉树是⽐红⿊树更严格的平衡树，为了保持保持平衡，需要旋转的次数更多，也就是
说平衡⼆叉树保持平衡的效率更低，所以平衡⼆叉树插⼊和删除的效率⽐红⿊树要低。
10.红⿊树怎么保持平衡的知道吗？
红⿊树有两种⽅式保持平衡： 旋转 和 染⾊ 。
旋转：旋转分为两种，左旋和右旋
1. ⾸先进⾏哈希值的扰动，获取⼀个新的哈希值。 (key == null) ? 0 : (h =
key.hashCode()) ^ (h >>> 16);
2. 判断tab是否位空或者长度为0，如果是则进⾏扩容操作。公众号 【三分恶】 出品
公众号 【三分恶】 出品
关注公众号：【三分恶】，获取手册最新动态！
73
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
3. 根据哈希值计算下标，如果对应⼩标正好没有存放数据，则直接插⼊即可否则需要覆
盖。 tab[i = (n - 1) & hash])
4. 判断tab[i]是否为树节点，否则向链表中插⼊数据，是则向树中插⼊节点。
5. 如果链表中插⼊节点的时候，链表长度⼤于等于8，则需要把链表转换为红⿊
树。 treeifyBin(tab, hash);
6. 最后所有元素处理完成后，判断是否超过阈值； threshold ，超过则扩容。
14.为什么哈希/扰动函数能降hash碰撞？
因为 key.hashCode() 函数调⽤的是 key 键值类型⾃带的哈希函数，返回 int 型散列值。int 值
范围为 -2147483648~2147483647，加起来⼤概 40 亿的映射空间。
只要哈希函数映射得⽐较均匀松散，⼀般应⽤是很难出现碰撞的。但问题是⼀个 40 亿长度的
数组，内存是放不下的。
假如 HashMap 数组的初始⼤⼩才 16，就需要⽤之前需要对数组的长度取模运算，得到的余数
才能⽤来访问数组下标。
源码中模运算就是把散列值和数组长度 - 1 做⼀个 " 与& " 操作，位运算⽐取余 % 运算要快。
bucketIndex = indexFor(hash, table.length);
static int indexFor(int h, int length) {
return h & (length-1);
}
顺便说⼀下，这也正好解释了为什么 HashMap 的数组长度要取 2 的整数幂。因为这样（数组
长度 - 1）正好相当于⼀个 “低位掩码”。 与 操作的结果就是散列值的⾼位全部归零，只保留
低位值，⽤来做数组下标访问。以初始长度 16 为例，16-1=15。2 进制表⽰是 0000 0000
0000 0000 0000 0000 0000 1111 。和某个散列值做 与 操作如下，结果就是截取了最低
的四位值。
这样是要快捷⼀些，但是新的问题来了，就算散列值分布再松散，要是只取最后⼏位的话，
碰撞也会很严重。如果散列本⾝做得不好，分布上成等差数列的漏洞，如果正好让最后⼏个
低位呈现规律性重复，那就更难搞了。
这时候 扰动函数 的价值就体现出来了，看⼀下扰动函数的⽰意图：
右移 16 位，正好是 32bit 的⼀半，⾃⼰的⾼半区和低半区做异或，就是为了混合原始哈希码
的⾼位和低位，以此来加⼤低位的随机性。⽽且混合后的低位掺杂了⾼位的部分特征，这样
⾼位的信息也被变相保留下来。
15.为什么HashMap的容量是2的倍数呢？
第⼀个原因是为了⽅便哈希取余：
将元素放在table数组上⾯，是⽤hash值%数组⼤⼩定位位置，⽽HashMap是⽤hash值&(数组⼤
⼩-1)，却能和前⾯达到⼀样的效果，这就得益于HashMap的⼤⼩是2的倍数，2的倍数意味着
该数的⼆进制位只有⼀位为1，⽽该数-1就可以得到⼆进制位上1变成0，后⾯的0变成1，再通
过&运算，就可以得到和%⼀样的效果，并且位运算⽐%的效率⾼得多
HashMap的容量是2的n次幂时，(n-1)的2进制也就是1111111***111这样形式的，这样与添加元
素的hash值进⾏位运算时，能够充分的散列，使得添加的元素均匀分布在HashMap的每个位置
上，减少hash碰撞。
第⼆个⽅⾯是在扩容时，利⽤扩容后的⼤⼩也是2的倍数，将已经产⽣hash碰撞的元素完
美的转移到新的table中去
我们可以简单看看HashMap的扩容机制，HashMap中的元素在超过 负载因⼦*HashMap ⼤⼩时
就会产⽣扩容。
16.如果初始化HashMap，传⼀个17的值 new HashMap<> new HashMap<> ，它会怎么处
理？
简单来说，就是初始化时，传的不是2的倍数时，HashMap会向上寻找 离得最近的2的倍数 ，
所以传⼊17，但HashMap的实际容量是32。
我们来看看详情，在HashMap的初始化中，有这样⼀段⽅法；
public HashMap(int initialCapacity, float loadFactor) {
...
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
阀值 threshold ，通过⽅法 tableSizeFor 进⾏计算，是根据初始化传的参数来计算的。
78
同时，这个⽅法也要要寻找⽐初始值⼤的，最⼩的那个2进制数值。⽐如传了17，我应该
找到的是32。
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;
}
MAXIMUM_CAPACITY = 1 << 30，这个是临界范围，也就是最⼤的Map集合。
计算过程是向右移位1、2、4、8、16，和原来的数做 | 运算，这主要是为了把⼆进制的
各个位置都填上1，当⼆进制的各个位置都是1以后，就是⼀个标准的2的倍数减1了，最后
把结果加1再返回即可。
以17为例，看⼀下初始化计算table容量的过程：
17.你还知道哪些哈希函数的构造⽅法呢？
HashMap⾥哈希构造函数的⽅法叫：
除留取余法 ：H（key)=key%p（p<=N）,关键字除以⼀个不⼤于哈希表长度的正整数p，
所得余数为地址，当然HashMap⾥进⾏了优化改造，效率更⾼，散列也更均衡。
除此之外，还有这⼏种常见的哈希函数构造⽅法：
直接定址法
直接根据 key 来映射到对应的数组位置，例如1232放到下标1232的位置。
数字分析法
取 key 的某些数字（例如⼗位和百位）作为映射的位置
平⽅取中法
取 key 平⽅的中间⼏位作为映射的位置
折叠法
将 key 分割成位数相同的⼏段，然后把它们的叠加和作为映射的位置
18.解决哈希冲突有哪些⽅法呢？
我们到现在已经知道，HashMap使⽤链表的原因为了处理哈希冲突，这种⽅法就是所谓的：
链地址法 ：在冲突的位置拉⼀个链表，把冲突的元素放进去。
除此之外，还有⼀些常见的解决冲突的办法：
开放定址法：开放定址法就是从冲突的位置再接着往下找，给冲突元素找个空位。
找到空闲位置的⽅法也有很多种：
线⾏探查法: 从冲突的位置开始，依次判断下⼀个位置是否空闲，直⾄找到空闲位置
平⽅探查法: 从冲突的位置x开始，第⼀次增加 1^2 个位置，第⼆次增加 2^2 …，直
⾄找到空闲的位置
……
再哈希法 ：换种哈希函数，重新计算冲突元素的地址。
建⽴公共溢出区 ：再建⼀个数组，把冲突的元素放进去。
19.为什么HashMap链表转红⿊树的阈值为8呢？
树化发⽣在table数组的长度⼤于64，且链表的长度⼤于8的时候。
为什么是8呢？源码的注释也给出了答案。
红⿊树节点的⼤⼩⼤概是普通节点⼤⼩的两倍，所以转红⿊树，牺牲了空间换时间，更多的
是⼀种兜底的策略，保证极端情况下的查找效率。
阈值为什么要选8呢？和统计学有关。理想情况下，使⽤随机哈希码，链表⾥的节点符合泊松
分布，出现节点个数的概率是递减的，节点个数为8的情况，发⽣概率仅为 0.00000006 。
⾄于红⿊树转回链表的阈值为什么是6，⽽不是8？是因为如果这个阈值也设置成8，假如发⽣
碰撞，节点增减刚好在8附近，会发⽣链表和红⿊树的不断转换，导致资源浪费。
20.扩容在什么时候呢？为什么扩容因⼦是0.75？
为了减少哈希冲突发⽣的概率，当当前HashMap的元素个数达到⼀个临界值的时候，就会触
发扩容，把所有元素rehash之后再放在扩容后的容器中，这是⼀个相当耗时的操作。
⽽这个 临界值threshold 就是由加载因⼦和当前容器的容量⼤⼩来确定的，假如采⽤默认的
构造⽅法：
临界值（threshold ）= 默认容量（DEFAULT_INITIAL_CAPACITY） * 默认扩容因⼦
（DEFAULT_LOAD_FACTOR）
那就是⼤于 16x0.75=12 时，就会触发扩容操作。
那么为什么选择了0.75作为HashMap的默认加载因⼦呢？
简单来说，这是对 空间 成本和 时间 成本平衡的考虑。
在HashMap中有这样⼀段注释：
我们都知道，HashMap的散列构造⽅式是Hash取余，负载因⼦决定元素个数达到多少时候扩
容。
假如我们设的⽐较⼤，元素⽐较多，空位⽐较少的时候才扩容，那么发⽣哈希冲突的概率就
增加了，查找的时间成本就增加了。
我们设的⽐较⼩的话，元素⽐较少，空位⽐较多的时候就扩容了，发⽣哈希碰撞的概率就降
低了，查找时间成本降低，但是就需要更多的空间去存储元素，空间成本就增加了。
22.jdk1.8对HashMap主要做了哪些优化呢？为什么？
jdk1.8 的HashMap主要有五点优化：
1. 数据结构：数组 + 链表改成了数组 + 链表或红⿊树
原因 ：发⽣ hash 冲突，元素会存⼊链表，链表过长转为红⿊树，将时间复杂度由 O(n)
降为 O(logn)
2. 链表插⼊⽅式：链表的插⼊⽅式从头插法改成了尾插法
简单说就是插⼊时，如果数组位置上已经有元素，1.7 将新元素放到数组中，原始节点作
为新节点的后继节点，1.8 遍历链表，将元素放置到链表的最后。
原因 ：因为 1.7 头插法扩容时，头插法会使链表发⽣反转，多线程环境下会产⽣环。
3. 扩容rehash：扩容的时候 1.7 需要对原数组中的元素进⾏重新 hash 定位在新数组的位
置，1.8 采⽤更简单的判断逻辑，不需要重新通过哈希函数计算位置，新的位置不变或索
引 + 新增容量⼤⼩。
原因： 提⾼扩容的效率，更快地扩容。
4. 扩容时机：在插⼊时，1.7 先判断是否需要扩容，再插⼊，1.8 先进⾏插⼊，插⼊完成再
判断是否需要扩容；
5. 散列函数：1.7 做了四次移位和四次异或，jdk1.8只做⼀次。
原因 ：做 4 次的话，边际效⽤也不⼤，改为⼀次，提升效率。
24.HashMap 是线程安全的吗？多线程下会有什么问题？
HashMap不是线程安全的，可能会发⽣这些问题：
多线程下扩容死循环。JDK1.7 中的 HashMap 使⽤头插法插⼊元素，在多线程的环境下，
扩容的时候有可能导致环形链表的出现，形成死循环。因此，JDK1.8 使⽤尾插法插⼊元
素，在扩容时会保持链表元素原本的顺序，不会出现环形链表的问题。
多线程的 put 可能导致元素的丢失。多线程同时执⾏ put 操作，如果计算出来的索引位置
是相同的，那会造成前⼀个 key 被后⼀个 key 覆盖，从⽽导致元素的丢失。此问题在 JDK
1.7 和 JDK 1.8 中都存在。
put 和 get 并发时，可能导致 get 为 null。线程 1 执⾏ put 时，因为元素个数超出 threshold
⽽导致 rehash，线程 2 此时执⾏ get，有可能导致这个问题。这个问题在 JDK 1.7 和 JDK
1.8 中都存在。
25.有什么办法能解决HashMap线程不安全的问题呢？
Java 中有 HashTable、Collections.synchronizedMap、以及 ConcurrentHashMap 可以实现线程安
全的 Map。
HashTable 是直接在操作⽅法上加 synchronized 关键字，锁住整个table数组，粒度⽐较
⼤；
Collections.synchronizedMap 是使⽤ Collections 集合⼯具的内部类，通过传⼊ Map 封装出
⼀个 SynchronizedMap 对象，内部定义了⼀个对象锁，⽅法内通过对象锁实现；
ConcurrentHashMap 在jdk1.7中使⽤分段锁，在jdk1.8中使⽤CAS+synchronized。
26.能具体说⼀下ConcurrentHashmap的实现吗？
ConcurrentHashmap线程安全在jdk1.7版本是基于 分段锁 实现，在jdk1.8是基于
CAS+synchronized 实现。
1.7分段锁
从结构上说，1.7版本的ConcurrentHashMap采⽤分段锁机制，⾥⾯包含⼀个Segment数组，
Segment继承于ReentrantLock，Segment则包含HashEntry的数组，HashEntry本⾝就是⼀个链表
的结构，具有保存key、value的能⼒能指向下⼀个节点的指针。
实际上就是相当于每个Segment都是⼀个HashMap，默认的Segment长度是16，也就是⽀持16
个线程的并发写，Segment之间相互不会受到影响。
put流程 整个流程和HashMap⾮常类似，只不过是先定位到具体的Segment，然后通过ReentrantLock去
操作⽽已，后⾯的流程，就和HashMap基本上是⼀样的。
1. 计算hash，定位到segment，segment如果是空就先初始化
2. 使⽤ReentrantLock加锁，如果获取锁失败则尝试⾃旋，⾃旋超过次数就阻塞获取，保证⼀
定获取锁成功
3. 遍历HashEntry，就是和HashMap⼀样，数组中key和hash⼀样就直接替换，不存在就再插
⼊链表，链表同样操作
get流程
get也很简单，key通过hash定位到segment，再遍历链表定位到具体的元素上，需要注意的是
value是volatile的，所以get是不需要加锁的。
1.8 CAS+synchronized
jdk1.8实现线程安全不是在数据结构上下功夫，它的数据结构和HashMap是⼀样的，数组+链
表+红⿊树。它实现线程安全的关键点在于put流程。
put流程
1. ⾸先计算hash，遍历node数组，如果node是空的话，就通过CAS+⾃旋的⽅式初始化
27.HashMap 内部节点是有序的吗？
HashMap是⽆序的，根据 hash 值随机插⼊。如果想使⽤有序的Map，可以使⽤LinkedHashMap
或者 TreeMap。
28.讲讲 LinkedHashMap 怎么实现有序的？
LinkedHashMap维护了⼀个双向链表，有头尾节点，同时 LinkedHashMap 节点 Entry 内部除了
继承 HashMap 的 Node 属性，还有 before 和 after ⽤于标识前置节点和后置节点。
可以实现按插⼊的顺序或访问顺序排序。
29.讲讲 TreeMap 怎么实现有序的？
TreeMap 是按照 Key 的⾃然顺序或者 Comprator 的顺序进⾏排序，内部是通过红⿊树来实
现。所以要么 key 所属的类实现 Comparable 接⼜，或者⾃定义⼀个实现了 Comparator 接⼜
的⽐较器，传给 TreeMap ⽤于 key 的⽐较。
30.讲讲HashSet的底层实现？
HashSet 底层就是基于 HashMap 实现的。（ HashSet 的源码⾮常⾮常少，因为除了 clone() 、
writeObject() 、 readObject() 是 HashSet⾃⼰不得不实现之外，其他⽅法都是直接调⽤
HashMap 中的⽅法。
HashSet的add⽅法，直接调⽤HashMap的put⽅法，将添加的元素作为key，new⼀个Object作为
value，直接调⽤HashMap的put⽅法，它会根据返回值是否为空来判断是否插⼊元素成功。
扫一扫
3172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
