Java后端高频知识点学习笔记2---Java集合

Java后端高频知识点学习笔记2---Java集合

参考地址：牛 _ 客 _ 网
https://www.nowcoder.com/discuss/819300

1、Java中有哪些集合

Java中的集合类主要由 Collection 和 Map 这两个接口派生出

• Collection接口又派生出三个子接口：Set、List、Queue

• • Set：HashSet、TreeSet
    List：ArrayList、LinkedList、Vector
    Queue：PriorityQueue、Deque

• Map接口下的集合：HashMap、ConcurrentHashMap、Hashtable、TreeMap
  

2、List、Set、Map三者的区别

List：存储的元素有序、可重复
Set：存储的元素无序、不可重复
Map：存储 键值对<Key,Value>；Key是无序的，不可重复；Value是无序的，可重复；每个键最多映射一个值，但同一个值可以被多个键映射

3、ArrayList和LinkedList的区别

（1）ArrayList基于 数组 实现；LinkedList基于 双向链表 实现
（2）对于随机访问，ArrayList要优于LinkedList，ArrayList可以根据下标以O(1)时间复杂度对元素进行随机访问，而LinkedList的每一个元素都依靠地址指针连接后一个元素，查找某个元素的时间复杂度是O(N)
（3）对于插入和删除操作，LinkedList要优于ArrayList，因为当元素被添加到LinkedList任意位置的时候，不需要像ArrayList更新索引
（4）LinkedList 比 ArrayList 更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素

4、有哪些线程安全的List

类	说明
Vector	Vector是比较古老的API，虽然保证了线程安全，但是由于效率低一般不建议使用
Collections.SynchronizedList	SynchronizedList是Collections的内部类，Collections提供了synchronizedList方法，可以将一个线程不安全的List包装成线程安全的List，即SynchronizedList；它比Vector有更好的扩展性和兼容性，但是它所有的方法都带有同步锁，也不是性能最优的List
CopyOnWriteArrayList	CopyOnWriteArrayList是Java 1.5在java.util.concurrent包下增加的类，它采用复制底层数组的方式来实现写操作；当线程对此类集合执行读取操作时，线程将会直接读取集合本身，无须加锁与阻塞；当线程对此类集合执行写入操作时，集合会在底层复制一份新的数组，接下来对新的数组执行写入操作；由于对集合的写入操作都是对数组的副本执行操作，因此它是线程安全的；在所有线程安全的List中，它是性能最优的方案

5、ArrayList和Vector的区别

ArrayList不是线程安全的，Vector是线程安全的
（线程安全：简单地说，在多个线程访问共享数据的情况下，依然正确地操作共享数据）

ArrayList中的方法不是同步的，Vector中的绝大多数方法都是直接或间接同步的
（同步，简单来说，就是所有的操作都完成才返回；异步，则是不等所有操作完成就返回）

6、ArrayList的扩容机制（基于jdk1.8）

1、ArrayList以无参构造方法创建ArrayList时，初始化赋值的是一个空数组，对数组进行添加元素操作时，才真正分配容量；当向ArrayList中添加第一个元素时，数组容量默认扩容为10

2、当需要扩容时，ArrayList每次扩容都以原来容量的1.5倍进行扩容

3、然后再判断新容量是否小于最小需要容量，如果还是小于最小需要容量，那就把最小需要容量当作数组的新容量，即不需要再进行扩容计算

4、然后判断新容量是否大于设定的最大容量MAX_ARRAY_SIZE
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//-8是为了避免oom
如果已经大于最大容量，则会调用hugeCapacity()方法，返回Integer的最大值

5、最后，通过Arrays.copyOf()方法将原数组中的内容放到扩容后的新数组里面

7、HashMap底层实现

分 JDK1.7 和 JDK1.8 回答
在JDK1.7时，HashMap的底层数据结构是：数组 + 链表
在JDK1.8时，HashMap的底层数据结构是：数组 + 链表 + 红黑树

put操作：
① 首先判断数组是否为空，如果数组为空则进行第一次扩容（resize）
② 根据key计算hash值并与上（数组的长度-1）得到键在数组中的索引（int index = key.hashCode() & (length-1) ）
③ 如果该位置为null，则直接插入
④ 如果该位置不为null，则判断key是否“相等”（ 先hashCode()再equals() ），如果“相等”，则直接覆盖value
⑤ 如果key不相等，则判断该元素是否为红黑树的节点，如果是，则直接在红黑树中插入键值对
⑥ 如果不是红黑树的节点，则就是链表，遍历这个链表仍未找到该key，执行插入操作；如果遍历过程中若发现key已存在，直接覆盖value即可
如果链表的长度大于等于8 且 元素数量大于等于阈值（64），则将链表转化为红黑树（先在链表中插入再进行判断）
如果链表的长度大于等于8 且 元素数量小于阈值（64），则先对数组进行扩容，不转化为红黑树
⑦ 插入成功后，若元素个数大于等于容量*负载因子，则扩容
触发扩容的条件：：①HashMap.Size >= Capacity * LoadFactor；②链表的长度大于等于8 且 元素数量小于阈值（64）
扩容步骤：1、resize：创建一个新Entry数组，长度是原来数组的2倍；2、rehash：遍历老Entry数组，把里面的每一个元素取出来重新计算其在新数组的index，将元素放入新数组

为什么负载因子设为0.75？
答：时间和空间的权衡，或者说是 查询效率与空间使用率的权衡；当负载因子是1的时候，容易出现大量Hash冲突，其底层的链表长度过长或者红黑树的高度过高时，查询效率降低；当负载因子是0.5的时候，Hash冲突减少，底层的链表长度或者是红黑树的高度降低，查询效率增加，但空间利用率降低

总结：负载因子是0.75的时候，查找效率 与 空间利用率 都比较高

get操作：
① 计算 key 的 hash 值，进而找到 key 在数组中的位置（ index = hash&(length -1)）
② 如果该位置为null，就直接返回null
③ 否则，根据 equals() 判断 key 与当前位置的key是否相等，如果相等，直接返回其值
④ 如果不等，再判断当前元素是否为树节点，如果是树节点就按红黑树进行查找；否则，按照链表的方式进行查找

8、HashMap的扩容机制

触发扩容的条件：：①HashMap.Size >= Capacity * LoadFactor；②链表的长度大于等于8 且 元素数量小于阈值（64）
1、数组的初始容量为16，之后以2的次方扩容，一是为了提高性能使用足够大的数组，二是为了能使用位运算代替取模预算（速度提升了5~8倍）
2、数组是否需要扩充是通过 当前元素个数 与 数组容量*负载因子 的大小关系 判断的，如果当前元素个数为数组容量的0.75时，就会扩充数组；这个0.75就是默认的负载因子，可由构造器传入指定的负载因子；例如：设置负载因子为1，牺牲性能，节省内存
3、为了解决碰撞，数组中的元素是单向链表类型；当链表长度到达一个阈值时(8)，会将链表转换成红黑树提高性能；而当链表长度缩小到另一个阈值时（6)，又会将红黑树转换回单向链表提高性能
4、对于第三点补充说明，检查链表长度转换成红黑树之前，还会先检测当前数组中元素个数是否到达一个阈值(64)，如果没有到达这个容量，会放弃转换，先去扩充数组；所以上面也说了链表长度的阈值是8，因为会有一次放弃转换的操作

9、HashMap为什么是线程不安全的

分JDK1.7和JDK1.8来答
1、在JDK1.7中，当并发执行扩容操作时会造成死循环和数据丢失的情况
在JDK1.7中，在多线程情况下同时对数组进行扩容，需要将原来数据转移到新数组中，在转移元素的过程中使用的是头插法，会造成死循环

2、在JDK1.8中，在并发执行put操作时会发生数据覆盖的情况
如果线程A和线程B同时进行put操作，刚好这两条不同的数据hash值一样，并且该位置数据为null，所以这线程A、B都会通过判断，将执行插入操作；假设 线程A 进入后还未进行数据插入时挂起，而 线程B 正常执行，从而正常插入数据，然后线程A获取CPU时间片，此时线程A不用再进行hash判断了，线程A 会把 线程B 插入的数据给覆盖，发生线程不安全

10、HashMap是如何解决哈希冲突的

拉链法（链地址法）
为了解决碰撞，数组中的元素是单向链表类型；当链表长度大于等于8时，会将链表转换成红黑树提高性能；而当链表长度小于等于6时，又会将红黑树转换回单向链表提高性能

11、HashMap为什么使用红黑树而不是B树或平衡二叉树AVL或二叉查找树

HashMap本来是数组+链表的形式，链表由于其 查找慢 的特点，所以需要被查找效率更高的树结构来替换

1、不使用二叉查找(/排序)树
二叉排序树在极端情况下会出现线性结构；例如：添加的元素越来越小，会导致左子树线性增长，这样就失去了用树型结构替换链表的初衷

2、不使用平衡二叉树
平衡二叉树是严格平衡的树，红黑树是不严格平衡的树，平衡二叉树在插入或删除后维持平衡的开销要大于红黑树
虽然红黑树查询性能略低于平衡二叉树，但在插入和删除上性能要优于平衡二叉树
选择红黑树是从功能、性能和开销上综合选择的结果

3、不使用B树/B+树
如果用B/B+树的话，在数据量不是很多的情况下，数据都会"挤在"一个结点里面，这个时候遍历效率就退化成了链表

12、HashMap 和 Hashtable 的区别

① HashMap是⾮线程安全的；Hashtable是线程安全的，Hashtable 内部的⽅法基本都经过 synchronized 修饰
② 因为线程安全的问题，HashMap要⽐Hashtable效率⾼⼀点
③ HashMap允许键或值是null，而Hashtable不允许键或值是null；HashMap中，null可以作为键，这样的键只有⼀个，可以有⼀个或多个键所对应的值为null；HashTable则不允许，当 put 进的键或值只要有⼀个 null，直接抛出 NullPointerException
④ HashMap默认的初始⼤⼩为16，之后每次扩充，容量变为原来的2倍；Hashtable默认的初始⼤⼩为11，之后每次扩充，容量变为原来的2n+1
⑤ 创建时如果给定了容量初始值，那么 Hashtable 会直接使⽤你给定的⼤⼩；⽽ HashMap 依然扩充为2的幂次⽅⼤⼩
⑥ JDK1.8 以后的 HashMap 在解决哈希冲突时当链表⻓度⼤于等于8时，将链表转化为红⿊树，以减少搜索时间；Hashtable没有这样的机制，Hashtable的底层，是以数组+链表的形式来存储

13、ConcurrentHashMap底层实现

JDK1.7
底层数据结构：Segments数组 + HashEntry数组 + 链表，采用分段锁保证安全性，对Segments上锁

• 一个ConcurrentHashMap中有一个Segments数组，一个Segments中存储一个HashEntry数组，每个HashEntry是一个链表结构的元素；Segments继承自ReentrantLock
• 原理：将数据分为一段一段的存储，给每一段数据配一把锁，当一个线程占用锁访问其中一段数据时，其他段的数据也能被其他线程访问，实现了真正的并发访问

get()操作：HashEntry 中的 value属性 和 next指针 是用volatile修饰的，保证了可见性，所以每次获取的都是最新值，因此，get()过程不需要加锁
get()操作流程
1、将key传入get方法中，先根据key的 hash值 找到对应的segment段
2、再根据segment中的get方法再次hash，找到HashEntry数组中的位置
3、最后在链表中根据hash值和equals()方法进行查找

• ConcurrentHashMap 的get操作跟HashMap类似，只是ConcurrentHashMap需要先经过一次hash定位找到对应的 Segment段，然后再hash定位到指定的HashEntry，遍历该HashEntry下的链表进行对比，成功就返回，不成功就返回null

put()操作流程：
1、将key传入put方法中，先根据 key的hash值 找到对应的segment段
2、再根据segment中的put方法，对该段数据加锁lock()
3、再次hash定位，确定存放的hashEntry数组中的位置
4、在链表中根据hash值和equals方法进行比较，如果相同就直接覆盖，如果不同就插入在链表中

JDK1.8

底层数据结构：Node数组 + 链表 + 红黑树；采用 Synchronized 和 CAS 来保证线程安全

get()操作：
get操作全程无锁；get操作可以无锁是由于 Node元素的值val 和 指针next 是用 volatile 修饰的，保证了可见性，所以每次获取的都是最新值

• 在多线程环境下，线程A修改节点的val或者新增节点的时候是对线程B可见的

get()操作流程
1、计算hash值，定位到Node数组中的位置
2、如果该位置为null，则直接返回null
3、如果该位置不为null，再判断该节点是红黑树节点还是链表节点；如果是红黑树节点，使用红黑树的查找方式来进行查找；如果是链表节点，遍历链表进行查找

put()操作流程
1、先判断Node数组有没有初始化，如果没有初始化先初始化，执行initTable()方法
2、根据key的进行hash定位，找到Node数组中的位置，如果不存在hash冲突，即该位置是null，直接CAS插入
3、如果存在hash冲突，就先对链表的头节点或者红黑树的头节点加synchronized锁
4、如果是链表，就遍历链表，如果key相同就执行覆盖操作，如果不同就将元素插入到链表的尾部，并且在链表长度大于8，Node数组的长度超过64时，会将链表的转化为红黑树，否则扩容
5、如果是红黑树，就按照红黑树的结构进行插入

14、ConcurrentHashMap和Hashtable的区别

1、底层数据结构
JDK1.7的ConcurrentHashMap底层采用：Segments数组 + HashEntry数组 + 链表
JDK1.8的ConcurrentHashMap底层采用：Node数组 + 链表 + 红黑树
Hashtable底层数据结构采用：数组 + 链表

2、实现线程安全的方式
JDK1.7中ConcurrentHashMap采用 分段锁 实现线程安全
JDK1.8中ConcurrentHashMap采用 对头节点加synchronized锁 和 CAS 来实现线程安全
Hashtable采用 synchronized 来实现线程安全；在方法上加synchronized同步锁

15、HashSet和TreeSet的异同

相同点
HashSet和TreeSet的元素都是不能重复的，都是线程不安全的

不同点
① HashSet中的元素可以为null，但TreeSet中的元素不能为null
② HashSet不能保证元素的排列顺序，TreeSet支持自然排序、定制排序两种排序方式
③ HashSet底层采用哈希表实现，TreeSet底层采用红黑树实现