集合类复习

I'm 程序员

已于 2022-03-31 17:30:51 修改

阅读量369

点赞数

文章标签： java

于 2022-03-29 16:40:21 首次发布

本文链接：https://blog.csdn.net/weixin_51304175/article/details/123822849

版权

1.java常见集合(容器)

Java中的集合类主要由Collection和Map这两个接口派生而出，其中Collection接口又派生出三个子接口，分别是Set、List、Queue。所有的Java集合类，都是Set、List、Queue、Map这四个接口的实现类，这四个接口将集合分成了四大类，其中

Set代表无序的，元素不可重复的集合；
List代表有序的，元素可以重复的集合；
Queue代表先进先出（FIFO）的队列；
Map代表具有映射关系（key-value）的集合，其所有的key是一个Set集合，即key无序且不能重复。

这些接口拥有众多的实现类，其中最常用的实现类有HashSet、TreeSet、ArrayList、LinkedList、ArrayDeque、HashMap、TreeMap、LinkedHashMap、ConcurrentHashMap等。

2.Map接口的实现类

Map接口有很多实现类，其中比较常用的有HashMap、LinkedHashMap、TreeMap、ConcurrentHashMap、Hashtable。

对于不需要排序的场景，优先考虑使用HashMap，因为它是性能最好的Map实现。如果需要保证线程安全，则可以使用ConcurrentHashMap。它的性能好于Hashtable，因为它在put时采用分段锁/CAS的加锁机制，而不是像Hashtable那样，无论是put还是get都做同步处理。

对于需要排序的场景，如果需要按插入顺序排序则可以使用LinkedHashMap，如果需要将key按自然顺序排列甚至是自定义顺序排列，则可以选择TreeMap。如果需要保证线程安全，则可以使用Collections工具类将上述实现类包装成线程安全的Map。

3.ArrayList和LinkedList区别

两者都继承了list，collection接口，但Linkedlist还继承了Queue接口
两者都是线程不安全的
扩容机制：
1.Arraylist是动态扩容机制，初始容量为10，扩容机制为1.5倍。初始最大容量为Integer.MAX_VALUE - 8，原因是防止内存溢出，增加容错率。但是实际最大容量还是可以达到Integer.MAX_VALUE

2.Linkedlist的扩容就是新建节点进行指针指向即可

增加元素：
1.Arraylist在尾部增加元素很快，时间复杂度为O（1），但是在中间增加元素需要移动大量的元素，时间复杂度为O（n）

2.Linkedlist在尾部和中间增加元素的时间复杂度都是O（1），但是在中间添加元素需要先遍历找到插入位置
删除元素机制和增加元素基本类似
查询元素
1.Arraylist中的get方法直接通过index去获取元素，时间复杂度为O（1）

2.Linkedlist中的就需要遍历链表，时间复杂度为O（n）
LinkedList比ArrayList更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。
总的来说，Arraylist支持高效的随机元素访问，LinkedList在插入和删除元素方面比较高效！

4.ArrayList线程安全吗，为什么，造成什么后果

不安全

它不安全的情况主要有这么几种(前提是多线程环境下)：

add元素之后，会出现有些位置的值为null的情况
数组下标越界
size大小不是预期的值

private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }

1.出现null的情况
假设两个线程A,B都执行add方法，此时size为2，线程A执行了elementData[s] = e添加元素，还没执行size = s + 1时，线程B也来执行elementData[s] = e，最后线程A,B都执行size+1。最终结果就是size为3的位置是线程B覆盖线程A的结果，size为4的位置是空。
2. 数组下标越界
假设两个线程A,B都执行add方法，此时size为9，数组长度为10。线程A在判断是否需要扩容时得出不需要扩容，执行elementData[s] = e添加元素操作，还没执行size = s + 1时，因为size=9线程B也判断出不需要扩容，执行elementData[s] = e添加操作。最后，线程A执行了size = s + 1,size为10，这时线程B也想执行size = s + 1,因为size已经是10了，所以会出现数组下标越界问题。
3.size大小不是预期的值
假设两个线程A,B都执行add方法，此时size为2，线程A执行了elementData[s] = e添加元素，此时，线程B也执行了elementData[s] = e添加元素。线程A和线程B同时拿到size，都进行了size+1，最后得出来的size是3，不是预期值4.
LinkedList同理

5.ArrayList和LinkedList的底层

ArrayList：

底层基于数组实现，支持对元素进行快速随机访问，支持元素重复；默认初始大小为10，当数组容量不够时，会触发扩容机制（扩大到当前的1.5倍），需要将原来数组的数据复制到新的数组中；当从 ArrayList 的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。

LinkedList：

底层基于双向链表实现，适合数据的动态插入和删除；内部提供了 List 接口中没有定义的方法，用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

6.看过HashMap的源码吗，底层实现原理。

1.map.put的实现原理

第一步：先把将key,value存放到Node（节点）对象中。

第二步：通过底层key的hashcode（）方法计算出key的hash值。

第三步：通过hash表/哈希算法，将hash值转化为数组的下标，下表位置上如果没有任何元素，那么将Node添加到这个位置上。如果下标位置已经存在链表，此时，将会拿着key和链表上的每个节点的key进行比较（equals方法）。如果所有的equlas方法返回的都是false，那么这个新的节点将被添加到链表的末尾，如果有一个equals返回true，那么这个节点的value将会被覆盖。

2.map.get实现原理

第一步：先调用key的hashCode()方法计算出它的hash值，并通过哈希算法将hash值转换为数组的下标。

第二步：通过数组的下标快速定位到某个位置上。如果这个位置上什么都没有，则返回null。如果这个位置上有单项链表，那么它将拿着参数k和单向链表上的每个节点的key进行比较，如果所有equals方法都返回false，那么get方法则返回null。如果返回true，那么此时的节点的value就是我们要找的value。

7.介绍一下HashMap的扩容机制

数组的初始容量为16，而容量是以2的次方扩充的，一是为了提高性能使用足够大的数组，二是为了能使用位运算代替取模预算(据说提升了5~8倍)。
数组是否需要扩充是通过负载因子判断的，如果当前元素个数为数组容量的0.75时，就会扩充数组。这个0.75就是默认的负载因子，可由构造器传入。我们也可以设置大于1的负载因子，这样数组就不会扩充，牺牲性能，节省内存。
为了解决碰撞，数组中的元素是单向链表类型。当链表长度到达一个阈值时（7或8），会将链表转换成红黑树提高性能。而当链表长度缩小到另一个阈值时（6），又会将红黑树转换回单向链表提高性能。
对于第三点补充说明，检查链表长度转换成红黑树之前，还会先检测当前数组数组是否到达一个阈值（64），如果没有到达这个容量，会放弃转换，先去扩充数组。所以上面也说了链表长度的阈值是7或8，因为会有一次放弃转换的操作。

8.JDK7和JDK8中的HashMap有什么区别？

参考答案

JDK7中的HashMap，是基于数组+链表来实现的，它的底层维护一个Entry数组。它会根据计算的hashCode将对应的KV键值对存储到该数组中，一旦发生hashCode冲突，那么就会将该KV键值对放到对应的已有元素的后面，此时便形成了一个链表式的存储结构。

JDK7中HashMap的实现方案有一个明显的缺点，即当Hash冲突严重时，在桶上形成的链表会变得越来越长，这样在查询时的效率就会越来越低，其时间复杂度为O(N)。

JDK8中的HashMap，是基于数组+链表+红黑树来实现的，它的底层维护一个Node数组。当链表的存储的数据个数大于等于8的时候，不再采用链表存储，而采用了红黑树存储结构。这么做主要是在查询的时间复杂度上进行优化，链表为O(N)，而红黑树一直是O(logN)，可以大大的提高查找性能。

9.比较 HashSet、LinkedHashSet 和 TreeSet 三者的异同

HashSet、LinkedHashSet 和 TreeSet 都是 Set 接口的实现类，都能保证元素唯一，并且都不是线程安全的。
HashSet、LinkedHashSet 和 TreeSet 的主要区别在于底层数据结构不同。HashSet 的底层数据结构是哈希表（基于 HashMap 实现）。LinkedHashSet 的底层数据结构是链表和哈希表，元素的插入和取出顺序满足 FIFO。TreeSet 底层数据结构是红黑树，元素是有序的，排序的方式有自然排序和定制排序。
底层数据结构不同又导致这三者的应用场景不同。HashSet 用于不需要保证元素插入和取出顺序的场景，LinkedHashSet 用于保证元素的插入和取出顺序满足 FIFO 的场景，TreeSet 用于支持对元素自定义排序规则的场景。

10. 说一说TreeSet和HashSet的区别

HashSet、TreeSet中的元素都是不能重复的，并且它们都是线程不安全的，二者的区别是：

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

11. 说一说HashSet的底层结构

HashSet是基于HashMap实现的，默认构造函数是构建一个初始容量为16，负载因子为0.75 的HashMap。它封装了一个 HashMap 对象来存储所有的集合元素，所有放入 HashSet 中的集合元素实际上由 HashMap 的 key 来保存，而 HashMap 的 value 则存储了一个 PRESENT，它是一个静态的 Object 对象。

12.有哪些线程安全的List？

Vector

Vector是比较古老的API，虽然保证了线程安全，但是由于效率低一般不建议使用。
Collections.SynchronizedList

SynchronizedList是Collections的内部类，Collections提供了synchronizedList方法，可以将一个线程不安全的List包装成线程安全的List，即SynchronizedList。它比Vector有更好的扩展性和兼容性，但是它所有的方法都带有同步锁，也不是性能最优的List。
CopyOnWriteArrayList

CopyOnWriteArrayList是Java 1.5在java.util.concurrent包下增加的类，它采用复制底层数组的方式来实现写操作。当线程对此类集合执行读取操作时，线程将会直接读取集合本身，无须加锁与阻塞。当线程对此类集合执行写入操作时，集合会在底层复制一份新的数组，接下来对新的数组执行写入操作。由于对集合的写入操作都是对数组的副本执行操作，因此它是线程安全的。在所有线程安全的List中，它是性能最优的方案。

13. 说一说你对LinkedHashMap的理解

LinkedHashMap使用双向链表来维护key-value对的顺序（其实只需要考虑key的顺序），该链表负责维护Map的迭代顺序，迭代顺序与key-value对的插入顺序保持一致。

LinkedHashMap可以避免对HashMap、Hashtable里的key-value对进行排序（只要插入key-value对时保持顺序即可），同时又可避免使用TreeMap所增加的成本。

LinkedHashMap需要维护元素的插入顺序，因此性能略低于HashMap的性能。但因为它以链表来维护内部顺序，所以在迭代访问Map里的全部元素时将有较好的性能。

14 请介绍LinkedHashMap的底层原理

LinkedHashMap继承于HashMap，它在HashMap的基础上，通过维护一条双向链表，解决了HashMap不能随时保持遍历顺序和插入顺序一致的问题。在实现上，LinkedHashMap很多方法直接继承自HashMap，仅为维护双向链表重写了部分方法。

如下图，淡蓝色的箭头表示前驱引用，红色箭头表示后继引用。每当有新的键值对节点插入时，新节点最终会接在tail引用指向的节点后面。而tail引用则会移动到新的节点上，这样一个双向链表就建立起来了。

15. 请介绍TreeMap的底层原理

TreeMap基于红黑树（Red-Black tree）实现。映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。TreeMap的基本操作containsKey、get、put、remove方法，它的时间复杂度是log(N)。

TreeMap包含几个重要的成员变量：root、size、comparator。其中root是红黑树的根节点。它是Entry类型，Entry是红黑树的节点，它包含了红黑树的6个基本组成：key、value、left、right、parent和color。Entry节点根据根据Key排序，包含的内容是value。Entry中key比较大小是根据比较器comparator来进行判断的。size是红黑树的节点个数。

16.HashMap与ConcurrentHashMap有什么区别？

HashMap是非线程安全的，这意味着不应该在多线程中对这些Map进行修改操作，否则会产生数据不一致的问题，甚至还会因为并发插入元素而导致链表成环，这样在查找时就会发生死循环，影响到整个应用程序。

Collections工具类可以将一个Map转换成线程安全的实现，其实也就是通过一个包装类，然后把所有功能都委托给传入的Map，而包装类是基于synchronized关键字来保证线程安全的（Hashtable也是基于synchronized关键字），底层使用的是互斥锁，性能与吞吐量比较低。

ConcurrentHashMap的实现细节远没有这么简单，因此性能也要高上许多。它没有使用一个全局锁来锁住自己，而是采用了减少锁粒度的方法，尽量减少因为竞争锁而导致的阻塞与冲突，而且ConcurrentHashMap的检索操作是不需要锁的。

17. HashMap为什么用红黑树而不用B树？

B/B+树多用于外存上时，B/B+也被成为一个磁盘友好的数据结构。

HashMap本来是数组+链表的形式，链表由于其查找慢的特点，所以需要被查找效率更高的树结构来替换。如果用B/B+树的话，在数据量不是很多的情况下，数据都会“挤在”一个结点里面，这个时候遍历效率就退化成了链表。

18. HashMap为什么线程不安全？

HashMap在并发执行put操作时，可能会导致形成循环链表，从而引起死循环。

19. HashMap中的循环链表是如何产生的（jdk1.8把头插法换成了尾插法的原因）？

blog.csdn.net/qq_36520235/article/details/86653136
在多线程的情况下，当重新调整HashMap大小的时候，就会存在条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了避免尾部遍历。如果条件竞争发生了，那么就会产生死循环了。

20. HashMap如何实现线程安全？

直接使用Hashtable类；
直接使用ConcurrentHashMap；
使用Collections将HashMap包装成线程安全的Map。

21. HashMap是如何解决哈希冲突的？

为了解决碰撞，数组中的元素是单向链表类型。当链表长度到达一个阈值时，会将链表转换成红黑树提高性能。而当链表长度缩小到另一个阈值时，又会将红黑树转换回单向链表提高性能。

22. 说一说HashMap和HashTable的区别

Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable的性能高一点。
Hashtable不允许使用null作为key和value，如果试图把null值放进Hashtable中，将会引发空指针异常，但HashMap可以使用null作为key或value。

I'm 程序员

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
集合类复习

1.java常见集合(容器)Java中的集合类主要由Collection和Map这两个接口派生而出，其中Collection接口又派生出三个子接口，分别是Set、List、Queue。所有的Java集合类，都是Set、List、Queue、Map这四个接口的实现类，这四个接口将集合分成了四大类，其中Set代表无序的，元素不可重复的集合；List代表有序的，元素可以重复的集合；Queue代表先进先出（FIFO）的队列；Map代表具有映射关系（key-value）的集合，其所有的key是一个Set集
复制链接

扫一扫