集合面试题

集合面试题

1.常用的集合类有哪些？

Map接口和Collection接口是所有集合框架的父接口：

　　1. Collection接口的子接口包括：Set接口和List接口

　　2. Map接口的实现类主要有：HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等

　　3. Set接口的实现类主要有：HashSet、TreeSet、LinkedHashSet等

　　4. List接口的实现类主要有：ArrayList、LinkedList、Stack以及Vector等

 

2.List，Set，Map三者的区别？List、Set、Map 是否继承自 Collection 接口？List、Map、Set 三个接口存取元素时，各有什么特点？

Collection集合主要有List和Set两大接口

　　List：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList

和 Vector。

　　Set：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、

LinkedHashSet 以及 TreeSet。

　　Map：是一个键值对集合，存储键、值和之间的映射。 Key无序，唯一；value 不要求有序，允许重复。Map没有继承于Collection接口，从Map集合中检索元

素时，只要给出键对象，就会返回对应的值对象。Map 的常用实现类：HashMap、TreeMap、HashTable、LinkedHashMap、ConcurrentHashMap

 

3.集合框架底层数据结构

List

Arraylist： Object数组

Vector： Object数组

LinkedList： 双向循环链表

 

1. Set

HashSet（无序，唯一）：基于 HashMap 实现的，底层采用 HashMap 来保

存元素

LinkedHashSet： LinkedHashSet 继承与 HashSet，并且其内部是通过LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基

于 Hashmap 实现一样，不过还是有一点点区别的。

TreeSet（有序，唯一）： 红黑树(自平衡的排序二叉树。)

 

HashMap： JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主

体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转

化为红黑树，以减少搜索时间

4.哪些集合类是线程安全的？

　　vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优

先考虑的。

　　statck：堆栈类，先进后出。

　　hashtable：就比hashmap多了个线程安全。

　　enumeration：枚举，相当于迭代器。

5.Java集合的快速失败机制 “fail-fast”？

　　是java集合的一种错误检测机制，当多个线程对集合进行结构上的改变的操作时，有可能会产生 fail-fast 机制。例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出ConcurrentModificationException 异常，从而产生fail-fast机制。原因：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。

 

6.怎么确保一个集合不能被修改？

　　可以使用 Collections. unmodifiableCollection(Collection c) 方法来创建一个只读集合，这样改变集合的任何操作都会抛出 Java. lang.UnsupportedOperationException 异常。

7.如何边遍历边移除 Collection 中的元素？

　　边遍历边修改 Collection 的唯一正确方式是使用 Iterator.remove() 方法，如下：

　　1 Iterator<Integer> it = list.iterator();

 

8.说一下 ArrayList 的优缺点

ArrayList的优点如下：

　　ArrayList 底层以数组实现，是一种随机访问模式。ArrayList 实现了RandomAccess 接口，因此查找的时候非常快。

　　ArrayList 在顺序添加一个元素的时候非常方便。

ArrayList 的缺点如下：

　　删除元素的时候，需要做一次元素复制操作。如果要复制的元素很多，那么就会比较耗费性能。

　　插入元素的时候，也需要做一次元素复制操作，缺点同上。

　　ArrayList 比较适合顺序添加、随机访问的场景。

9.ArrayList 和 LinkedList 的区别是什么？

　　1.数据结构实现：ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链

表的数据结构实现。

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

　　3.内存空间占用：LinkedList 比 ArrayList 更占内存，因为 LinkedList 的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。

　　4.线程安全：ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；综合来说，在需要频繁读取集合中的元素时，更推荐使用 ArrayList，而在插入和删除操作较多时，更推荐使用 LinkedList。

 10.ArrayList 和 Vector 的区别是什么？

这两个类都实现了 List 接口（List 接口继承了 Collection 接口），他们都是有

序集合

　　线程安全：Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而ArrayList 是非线程安全的。

　　性能：ArrayList 在性能方面要优于 Vector。

　　扩容：ArrayList 和 Vector 都会根据实际的需要动态的调整容量，只不过在Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%。

　　Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。Arraylist不是同步的，所以在不需要保证线程安全时时建议使用Arraylist。

11.List 和 Set 的区别

List , Set 都是继承自Collection 接口

　　List 特点：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。

　　Set 特点：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是HashSet、LinkedHashSet 以及 TreeSet。

另外 List 支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。

　　Set和List对比

　　Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。

　　List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变

12.说一下 HashSet 的实现原理？

　　HashSet 是基于 HashMap 实现的，HashSet的值存放于HashMap的key上，HashMap的value统一为PRESENT，因此 HashSet 的实现比较简单，相关HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成，HashSet 不允许重复的值。

13.HashSet如何检查重复？HashSet是如何保证数据不可重复的？

　　向HashSet 中add ()元素时，判断元素是否存在的依据，不仅要比较hash值，同时还要结合equles 方法比较。HashSet 中的add ()方法会使用HashMap 的put()方法。HashMap 的 key 是唯一的，由源码可以看出 HashSet 添加进去的值就是作为HashMap 的key，并且在HashMap中如果K/V相同时，会用新的V覆盖掉旧的V，然后返回旧的V。所以不会重复（ HashMap 比较key是否相等是先比较hashcode 再比较equals ）。

14.BlockingQueue是什么？

　　Java.util.concurrent.BlockingQueue是一个队列，在进行检索或移除一个元素的时候，它会等待队列变为非空；当在添加一个元素时，它会等待队列中的可用

空间。BlockingQueue接口是Java集合框架的一部分，主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间，或消费者有可用的对象，

因为它都在BlockingQueue的实现类中被处理了。

15.说一下 HashMap 的实现原理？

　　HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提

供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，

特别是它不保证该顺序恒久不变。

　　HashMap的数据结构：java1.8之前：数组+链表；java1.8之后，数组+红黑树。

HashMap 基于 Hash 算法实现的

　　1. 当我们往Hashmap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标

　　2. 存储时，如果出现hash值相同的key，此时有两种情况。(1)如果key相同，则覆盖原始值；(2)如果key不同（出现冲突），则将当前的key-value放入链表中

　　3. 获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。

　　4. 理解了以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。

需要注意Jdk 1.8中对HashMap的实现做了优化，当链表中的节点数据超过八个之后，该链表会转为红黑树来提高查询效率，从原来的O(n)到O(logn)

16.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，如果超过，进行扩容。

17.HashMap的扩容操作是怎么实现的？

 

①.在jdk1.8中，resize方法是在hashmap中的键值对大于阀值时或者初始化时，就调用resize方法进行扩容；

②.每次扩展的时候，都是扩展2倍；③.扩展后Node对象的位置要么在原位置，要么移动到原偏移量两倍的位置。在putVal()中，我们看到在这个函数里面使用到了2次resize()方法，resize()方

法表示的在进行第一次初始化时会对其进行扩容，或者当该数组的实际大小大于其临界值值(第一次为12),这个时候在扩容的同时也会伴随的桶上面的元素进行重新分发，这也是JDK1.8版本的一个优化的地方，在1.7中，扩容之后需要重新去计算其Hash值，根据Hash值对其进行分发，但在1.8版本中，则是根据在同

一个桶的位置中进行判断(e.hash & oldCap)是否为0，重新进行hash分配后，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上

18.HashMap是怎么解决哈希冲突的？

　　Hash，一般翻译为“散列”，也有直接音译为“哈希”的，这就是把任意长度的输入通过散列算法，变换成固定长度的输出，该输出就是散列值（哈希值）；

这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简

单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。所有散列函数都有如下一个基本特性**：根据同一散列函数计算出的散列值如果

不同，那么输入值肯定也不同。但是，根据同一散列函数计算出的散列值如果相同，输入值不一定相同**。

　

　　当两个不同的输入值，根据同一散列函数计算出相同的散列值的现象，我们就把它叫做碰撞（哈希碰撞）。

HashMap的数据结构

在Java中，保存数据有两种比较简单的数据结构：数组和链表。数组的特点是：寻址容易，插入和删除困难；链表的特点是：寻址困难，但插入和删除容易；所

以我们将数组和链表结合在一起，发挥两者各自的优势，使用一种叫做链地址法、的方式可以解决哈希冲突：

　　这样我们就可以将拥有相同哈希值的对象组织成一个链表放在hash值所对应的bucket下，但相比于hashCode返回的int类型，我们HashMap初始的容量大

小DEFAULT_INITIAL_CAPACITY = 1 << 4（即2的四次方16）要远小于int类型的范围，所以我们如果只是单纯的用hashCode取余来获取对应的bucket这将会

大大增加哈希碰撞的概率，并且最坏情况下还会将HashMap变成一个单链表，所以我们还需要对hashCode作一定的优化

　　hash()函数

　　上面提到的问题，主要是因为如果使用hashCode取余，那么相当于参与运算的只有hashCode的低位，高位是没有起到任何作用的，所以我们的思路就是让

hashCode取值出的高位也参与运算，进一步降低hash碰撞的概率，使得数据分布更平均，我们把这样的操作称为扰动，在JDK 1.8中的hash()函数如下：

　　1 static final int hash(Object key) {

　　2 int h;

　　3 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 与自己右

　　移16位进行异或运算（高低位异或）

　　4 }

　　这比在JDK 1.7中，更为简洁，相比在1.7中的4次位运算，5次异或运算（9次扰动），在1.8中，只进行了1次位运算和1次异或运算（2次扰动）；

　　通过上面的链地址法（使用散列表）和扰动函数我们成功让我们的数据分布更平均，哈希碰撞减少，但是当我们的HashMap中存在大量数据时，加入我们某个

bucket下对应的链表有n个元素，那么遍历时间复杂度就为O(n)，为了针对这个问题，JDK1.8在HashMap中新增了红黑树的数据结构，进一步使得遍历复杂度

降低至O(logn)

　　总结

简单总结一下HashMap是使用了哪些方法来有效解决哈希冲突的：

　　1. 使用链地址法（使用散列表）来链接拥有相同hash值的数据；

　　2. 使用2次扰动函数（hash函数）来降低哈希冲突的概率，使得数据分布更平均；

　　3. 引入红黑树进一步降低遍历的时间复杂度，使得遍历更快；

19.能否使用任何类作为 Map 的 key？

 可以使用任何类作为 Map 的 key，然而在使用之前，需要考虑以下几点：

　　1.如果类重写了 equals() 方法，也应该重写 hashCode() 方法。类的所有实例需要遵循与 equals() 和 hashCode() 相关的规则。

　　2.如果一个类没有使用 equals()，不应该在 hashCode() 中使用它。

　　3.用户自定义 Key 类最佳实践是使之为不可变的，这样 hashCode() 值可以被缓存起来，拥有更好的性能。不可变的类也可以确保 hashCode()

和 equals() 在未来不会改变，这样就会解决与可变相关的问题了。

20.为什么HashMap中String、Integer这样的包装类适合作为K？

　　String、Integer等包装类的特性能够保证Hash值的不可更改性和计算准确

性，能够有效的减少Hash碰撞的几率

　　1. 都是final类型，即不可变性，保证key的不可更改性，不会存在获取

hash值不同的情况

　　2. 内部已重写了equals()、hashCode()等方法，遵守了HashMap内部的规

范（不清楚可以去上面看看putValue的过程），不容易出现Hash值计算

错误的情况；

21.HashMap为什么不直接使用hashCode()处理后的哈希、值直接作为table的下标？

　　hashCode()方法返回的是int整数类型，其范围为-(2 ^ 31)~(2 ^ 31 - 1)，约有40亿个映射空间，而HashMap的容量范围是在16（初始化默认值）~2 ^

30，HashMap通常情况下是取不到最大值的，并且设备上也难以提供这么多的存储空间，从而导致通过hashCode()计算出的哈希值可能不在数组大小范围内，

进而无法匹配存储位置；

 

22.HashMap 的长度为什么是2的幂次方？

　　为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀，每个链表/红黑树长度大致相同。这个实现就是把数据存到哪个链表/红黑树

中的算法

这个算法应该如何设计呢？

　　我们首先可能会想到采用%取余的操作来实现。但是，重点来了：“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说

hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。” 并且 采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap

的长度为什么是2的幂次方。

那为什么是两次扰动呢？

　　答：这样就是加大哈希值低位的随机性，使得分布更均匀，从而提高对应数组存储下标位置的随机性&均匀性，最终减少Hash冲突，两次就够了，已经达到了

高位低位同时参与运算的目的；

23.HashMap 与 HashTable 有什么区别？

　　1. 线程安全： HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 synchronized 修饰。（如果你要保证线

程安全的话就使用 ConcurrentHashMap 吧！）；

　　2. 效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它；

　　3. 对Null key 和Null value的支持： HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在

HashTable 中 put 进的键值只要有一个 null，直接抛NullPointerException。

　　4. **初始容量大小和每次扩充容量大小的不同 **： ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原

来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接

使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小，后面会介绍到为什么是2

的幂次方。

　　5. 底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以

减少搜索时间。Hashtable 没有这样的机制。

 

24.ConcurrentHashMap 底层具体实现知道吗？实现原理是什么？

JDK1.7

　　首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。

在JDK1.7中，ConcurrentHashMap采用Segment + HashEntry的方式进行实现，结构如下：

一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似，是一种数组和链表结构，一个 Segment 包含一个 HashEntry

数组，每个 HashEntry 是一个链表结构的元素，每个 Segment 守护着一个HashEntry数组里的元素，当对 HashEntry 数组的数据进行修改时，必须首先

获得对应的 Segment的锁

　　1. 该类包含两个静态内部类 HashEntry 和 Segment ；前者用来封装映射表的键值对，后者用来充当锁的角色；

　　2. Segment 是一种可重入的锁 ReentrantLock，每个 Segment 守护一个HashEntry 数组里得元素，当对 HashEntry 数组的数据进行修改时，

必须首先获得对应的 Segment 锁。

JDK1.8

　　在JDK1.8中，放弃了Segment臃肿的设计，取而代之的是采用Node + CAS+ Synchronized来保证并发安全进行实现，synchronized只锁定当前链表或

红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。

结构如下：