前言

本文快速复习Java中容器的知识点，可用于面试复习，事半功倍。

其他知识点的复习手册

Java基础知识面试手册快速组合23种常见设计模式Redis基础知识面试手册

概览

容器主要包括集合和映射，集合还包括列表、集合和队列。

收藏品

在此插入图片说明。

在此插入图片说明。

数组和集合的区别：

长度数组的长度是固定的，集合的长度是可变的。内容数组存储相同类型的元素。它可以存储不同类型的元素(但通常我们不这样做.).数据类型数组的元素可以存储基本数据类型或引用类型集合只能存储引用类型(如果存储的是简单的int，会自动装箱成整数)。1.Set(元素不能重复)。

Hashset:基于HashMap实现，支持快速搜索，但不支持有序性操作. Treeset:基于红黑树实现，支持有序性操作,但是搜索效率不如HashSet，HashSet查找时间复杂度为O(1)，TreeSet则为O(logN)；链接HashSet:具有HashSet，且内部使用链表维护元素的插入顺序. 2的搜索效率。列表(有序(存储顺序与检索顺序一致)，可重复)

ArrayList:基于动态数组实现，支持随机访问；Vector:类似ArrayList，但它是线程安全的；LinkedList:基于双向链表的实现，只能顺序访问，但可以快速插入和删除链表中间的元素。不仅如此，LinkedList还可以用作堆栈、队列和双向队列。3.长队

LinkedList:可用于支持双向队列；PriorityQueue:基于堆结构的实现，可以用来实现优先级队列。地图

在此插入图片说明。

HashMap:基于hash的实现；HashTable:类似于HashMap，但它是线程安全的，这意味着多个线程可以同时写入HashTable，而不会导致数据不一致。是遗留类，不应该去使用它. ConcurrentHashMap:支持线程安全，ConcurrentHashMap会更高效，因为concurrent hashmap引入了分段锁。链接散列表：使用链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。树图：基于红黑树的实现。故障快速机制和故障安全机制

https://blog.csdn.net/Kato_op/article/details/80356618

快速失效

Fail-fast机制是java集合中的一个错误机制。当多个线程对同一集合的内容进行操作时，可能会发生快速失败事件。

迭代器在遍历过程中直接访问集合的内容，并在遍历过程中使用一个modCount变量。如果在遍历过程中集合的内容发生变化(增删改), modCount的值也将发生变化。每次迭代器使用hashNext()/next()遍历下一个元素时，都会执行checkForComodification()方法，检查modCount变量和expectedmodCount值是否相等，如果相等，则返回遍历结果；否则，将抛出一个异常，遍历将被终止。注意,如果在集合改变时修改了modCount值，并且恰好设置为expectedmodCount值，则不会抛出异常(比如删除数据，再添加一段数据)。

所以，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。

迭代器应该仅用于检测程序错误，而不是用他来同步。的快速失效行为

java.util包下的集合类都是Fail-Fast机制的，不能在多线程下发生并发修改(迭代过程中被修改).

自动防故障

当遍历而是先copy原有集合内容，在拷贝的集合上进行遍历.时，不直接在集合内容上访问具有故障安全机制的集合容器

原理：

因为在迭代过程中遍历了原始集合副本的值，所以迭代器无法检测到遍历过程中对原始集合所做的更改，所以不会设置并发定义异常。

缺点：

迭代器并不能访问到修改后的内容(简单来说，迭代器遍历的是开始遍历时获得的集合的副本，遍历过程中迭代器并不知道对原集合的修改)。

>使用场景:

java.util.concurrent包下的容器都是Fail-Safe的,可以在多线程下并发使用,并发修改

容器中使用的设计模式

迭代器模式

在这里插入图片描述

Iterator它是在ArrayList等集合的内部类的方式实现

Collection实现了Iterable接口，其中的iterator()方法能够产生一个Iterator对象，通过这个对象就可以迭代遍历Collection中的元素。

从JDK1.5之后可以使用foreach方法来遍历实现了Iterable接口的聚合对象。

适配器模式

适配器模式解释：https://www.jianshu.com/p/93821721bf08

java.util.Arrays#asList()可以把数组类型转换为List类型。

如果要将数组类型转换为List类型，应该注意的是asList()的参数为泛型的变长参数，因此不能使用基本类型数组作为参数，只能使用相应的包装类型数组。

也可以使用以下方式生成List。

源码分析

ArrayList

关键词

默认大小为10扩容1.5倍，加载因子为0.5基于动态数组实现删除元素时不会减少容量，若希望减少容量则调用trimToSize()它不是线程安全的它能存放null值。扩容操作需要调用Arrays.copyOf()把原数组整个复制到新数组删除需要调用System.arraycopy()将index+1后面的元素都复制到index位置上，复制的代价很高。
-序列化：只序列化数组中有元素填充那部分内容

概览

在这里插入图片描述

实现了RandomAccess接口，因此支持随机访问。这是理所当然的，因为ArrayList是基于数组实现的。

扩容

如果不够时，需要使用grow()方法进行扩容，新容量的大小为oldCapacity+(oldCapacity>>1)，也就是旧容量的1.5倍。

扩容操作需要调用Arrays.copyOf()把原数组整个复制到新数组中

因此最好在创建ArrayList对象时就指定大概的容量大小，减少扩容操作的次数。

加入元素：add

add(Ee)

首先去检查一下数组的容量是否足够

足够：直接添加不足够：扩容

扩容到原来的1.5倍，第一次扩容后，如果容量还是小于minCapacity，就将容量扩充为minCapacity。

add(intindex,Eelement)

步骤：

检查角标空间检查，如果有需要进行扩容插入元素

删除元素：remove

步骤：

检查角标删除元素计算出需要移动的个数，并移动设置为null，让GC回收（所以说不是立刻回收，而是等待GC回收）

需要调用System.arraycopy()将index+1后面的元素都复制到index位置上，复制的代价很高。

复制数组：System.arraycopy()

看到arraycopy()，我们可以发现：该方法是由C/C++来编写的

在这里插入图片描述

Fail-Fast

modCount用来记录ArrayList结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。

在进行序列化或者迭代等操作时，需要比较操作前后modCount是否改变，如果改变了需要抛出ConcurrentModificationException。

构造器

ArrayList提供了三种方式的构造器：

publicArrayList()可以构造一个默认初始容量为10的空列表；publicArrayList(intinitialCapacity)构造一个指定初始容量的空列表；publicArrayList(Collectionc)构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的。

序列化

补充：transient讲解

http://www.importnew.com/21517.html

你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

ArrayList基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。

保存元素的数组elementData使用transient修饰，该关键字声明数组默认不会被序列化。

ArrayList实现了writeObject()和readObject()来控制只序列化数组中有元素填充那部分内容。

序列化时需要使用ObjectOutputStream的writeObject()将对象转换为字节流并输出。而writeObject()方法在传入的对象存在writeObject()的时候会去反射调用该对象的writeObject()来实现序列化。反序列化使用的是ObjectInputStream的readObject()方法，原理类似。

Vector

关键词

默认大小为10（与Arraylist相同）扩容2倍，加载因子是1（Arraylist是扩容1.5倍，加载因子为0.5）其它几乎与ArrayList完全相同，唯一的区别在于Vector是同步的，因此开销就比ArrayList要大，访问速度更慢。使用了synchronized进行同步Vector是jdk1.2的类了，比较老旧的一个集合类。应使用JUC的CopyOnWriteArrayList代替

替代方案

可以使用Collections.synchronizedList();得到一个线程安全的ArrayList。

也可以使用concurrent并发包下的CopyOnWriteArrayList类。

CopyOnWriteArrayList

关键词

写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。写操作需要加锁，防止并发写入时导致写入数据丢失。写操作结束之后需要把原始数组指向新的复制数组。适用于读操作远大于写操作的场景。

读写分离

适用场景

CopyOnWriteArrayList在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。

缺陷

内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。

所以CopyOnWriteArrayList不适合内存敏感以及对实时性要求很高的场景。

LinkedList

关键词

双向链表默认大小为10带Head和Tail指针Node存储节点信息

概览

在这里插入图片描述

基于双向链表实现，内部使用Node来存储链表节点信息。

每个链表存储了Head和Tail指针：

在这里插入图片描述

ArrayList与LinkedList比较

ArrayList基于动态数组实现，LinkedList基于双向链表实现；ArrayList支持随机访问，LinkedList不支持；LinkedList在任意位置添加删除元素更快。

删除元素：remove

在这里插入图片描述

获取元素：get

下标小于长度的一半，从头遍历反之，从尾部遍历

替换元素：set

set方法和get方法其实差不多，根据下标来判断是从头遍历还是从尾遍历

其他方法

LinkedList实现了Deque接口，因此，我们可以操作LinkedList像操作队列和栈一样

LinkedList的方法比ArrayList的方法多太多了，这里我就不一一说明了。具体可参考：

https://blog.csdn.net/panweiwei1994/article/details/77110354https://zhuanlan.zhihu.com/p/24730576https://zhuanlan.zhihu.com/p/28373321

HashMap

http://wiki.jikexueyuan.com/project/java-collection/hashmap.html

源码分析：https://segmentfault.com/a/1190000014293372

关键词

初始容量16扩容是2倍，加载因子0.75头插法0桶存放null从JDK1.8开始，一个桶存储的链表长度大于8时会将链表转换为红黑树（前提：键值对要超过64个）自动地将传入的容量转换为2的幂次方保证运算速度：确保用位运算代替模运算来计算桶下标。hash&(length-1)运算等价于对length取模。hash均匀分布：数据在数组上分布就比较均匀，并且能够利用全部二进制位，也就是说碰撞的几率小，table数组+Entry[]链表（散列表），红黑树扩容操作需要把键值对重新插入新的table中，重新计算所有key有特殊机制（JDK1.8后）

存储结构

hashMap的一个内部类Node：

在这里插入图片描述

Node内部包含了一个Entry类型的数组table，数组中的每个位置被当成一个桶。

Entry存储着键值对。它包含了四个字段，从next字段我们可以看出Entry是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。

HashMap使用拉链法来解决冲突，同一个链表中存放哈希值相同的Entry。

构造器

在这里插入图片描述

构造时就会调用tableSizeFor()：返回一个大于输入参数且最近的2的整数次幂。

拉链法

应该注意到链表的插入是以头插法方式进行的

新建一个HashMap，默认大小为16；插入<K1,V1>键值对，先计算K1的hashCode为115，使用除留余数法得到所在的桶下标115%16=3。插入<K2,V2>键值对，先计算K2的hashCode为118，使用除留余数法得到所在的桶下标118%16=6。插入<K3,V3>键值对，先计算K3的hashCode为118，使用除留余数法得到所在的桶下标118%16=6，插在<K2,V2>前面。

查找需要分成两步进行：

计算键值对所在的桶；在链表上顺序查找，时间复杂度显然和链表的长度成正比。

put操作

当我们put的时候，如果key存在了，那么新的value会代替旧的value如果key存在的情况下，该方法返回的是旧的value，如果key不存在，那么返回null。

HashMap允许插入键为null的键值对。但是因为无法调用null的hashCode()方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap使用第0个桶存放键为null的键值对。

使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。

补充：hashmap里hash方法的高位优化：

https://www.cnblogs.com/liujinhong/p/6576543.html

https://note.youdao.com/yws/res/18743/50AADC7BB42845B29CDA293FC409250C?ynotemdtimestamp=1548155508277

设计者将key的哈希值的高位也做了运算(与高16位做异或运算，使得在做&运算时，此时的低位实际上是高位与低位的结合)，这就增加了随机性，减少了碰撞冲突的可能性！

为何要这么做？

table的长度都是2的幂，因此index仅与hash值的低n位有关，hash值的高位都被与操作置为0了。

这样做很容易产生碰撞。设计者权衡了speed,utility,andquality，将高16位与低16位异或来减少这种影响。设计者考虑到现在的hashCode分布的已经很不错了，而且当发生较大碰撞时也用树形存储降低了冲突。仅仅异或一下，既减少了系统的开销，也不会造成的因为高位没有参与下标的计算(table长度比较小时)，从而引起的碰撞。

确定桶下标

很多操作都需要先确定一个键值对所在的桶下标。

4.1计算hash值

4.2取模

令x=1<<\4，即\x为2的4次方，它具有以下性质：

令一个数y与x-1做与运算，可以去除y位级表示的第4位以上数：

这个性质和y对x取模效果是一样的：

我们知道，位运算的代价比求模运算小的多，因此在进行这种计算时用位运算的话能带来更高的性能。

确定桶下标的最后一步是将key的hash值对桶个数取模：hash%capacity，如果能保证capacity为2的n次方，那么就可以将这个操作转换为位运算。

当length总是2的n次方时，h&(length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。这看上去很简单，其实比较有玄机的，我们举个例子来说明：

h&(table.length-1)hashtable.length-18&(15-1)：0100&1110=01009&(15-1)：0101&1110=01008&(16-1)：0100&1111=01009&(16-1)：0101&1111=0101

从上面的例子中可以看出：当它们和15-1（1110）“与”的时候，8和9产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到数组中的同一个位置上形成链表，那么查询的时候就需要遍历这个链表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hash值会与15-1（1110）进行“与”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率。而当数组长度为16时，即为2的n次方时，2n-1得到的二进制数的每个位上的值都为1，这使得在低位上&时，得到的和原hash的低位相同，加之hash(inth)方法对key的hashCode的进一步优化，加入了高位计算，就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。

所以说，当数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小

扩容-基本原理

设HashMap的table长度为M，需要存储的键值对数量为N，如果哈希函数满足均匀性的要求，那么每条链表的长度大约为N/M，因此平均查找次数的复杂度为O(N/M)。

为了让查找的成本降低，应该尽可能使得N/M尽可能小，因此需要保证M尽可能大，也就是说table要尽可能大。HashMap采用动态扩容来根据当前的N值来调整M值，使得空间效率和时间效率都能得到保证。

和扩容相关的参数主要有：capacity、size、threshold和load_factor。

参数含义capacitytable的容量大小，默认为16。需要注意的是capacity必须保证为2的n次方。size键值对数量。thresholdsize的临界值，当size大于等于threshold就必须进行扩容操作。loadFactor装载因子，table能够使用的比例，threshold=capacity*loadFactor。

从下面的添加元素代码中可以看出，当需要扩容时，令capacity为原来的两倍。

扩容使用resize()实现，需要注意的是，扩容操作同样需要把oldTable的所有键值对重新插入newTable中，因此这一步是很费时的。

扩容-重新计算桶下标

Rehash优化：https://my.oschina.net/u/3568600/blog/1933764

在进行扩容时，需要把键值对重新放到对应的桶上。HashMap使用了一个特殊的机制，可以降低重新计算桶下标的操作。

假设原数组长度capacity为16，扩容之后newcapacity为32：

对于一个Key，

它的哈希值如果在第5位上为0，那么取模得到的结果和之前一样；如果为1，那么得到的结果为原来的结果+16。

总结：

经过rehash之后，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置

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

在这里插入图片描述

计算数组容量

HashMap构造函数允许用户传入的容量不是2的n次方，因为它可以自动地将传入的容量转换为2的n次方。

先考虑如何求一个数的掩码，对于10010000，它的掩码为11111111，可以使用以下方法得到：

mask+1是大于原始数字的最小的2的n次方。

以下是HashMap中计算数组容量的代码：

链表转红黑树

并不是桶子上有8位元素的时候它就能变成红黑树，它得同时满足我们的键值对大于64才行的

这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。

HashTable

关键词：

Hashtable的迭代器不是fail-fast，HashMap的迭代器是fail-fast迭代器。Hashtable的key和value都不允许为null，HashMap可以插入键为null的Entry。HashTable使用synchronized来进行同步。基于Dictionary类（遗留类）HashMap不能保证随着时间的推移Map中的元素次序是不变的。

HashMap与HashTable

在这里插入图片描述

HashTable基于Dictionary类（遗留类），而HashMap是基于AbstractMap。Dictionary是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的实现，它以最大限度地减少实现此接口所需的工作。HashMap的key和value都允许为null，而Hashtable的key和value都不允许为nullHashMap的迭代器是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。Hashtable中的几乎所有的public的方法都是synchronized的，而有些方法也是在内部通过synchronized代码块来实现。但是在Collections类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的Map对象，并把它作为一个封装的对象来返回。也可以使用ConcurrentHashMap，它是HashTable的替代，而且比HashTable可扩展性更好

ConcurrentHashMap

谈谈ConcurrentHashMap1.7和1.8的不同实现：

http://www.importnew.com/23610.html

详细源码分析（还未细看）：

https://blog.csdn.net/yan_wenliang/article/details/51029372

https://segmentfault.com/a/1190000014380257

主要针对jdk1.7的实现来介绍

关键词

key和value都不允许为nullHashtable是将所有的方法进行同步，效率低下。而ConcurrentHashMap通过部分锁定+CAS算法来进行实现线程安全的get方法是非阻塞，无锁的。重写Node类，通过volatile修饰next来实现每次获取都是最新设置的值在高并发环境下，统计数据(计算size…等等)其实是无意义的，因为在下一时刻size值就变化了。实现形式不同：1.7：Segment+HashEntry的方式进行实现1.8：与HashMap相同（散列表（数组+链表）+红黑树）采用Node数组+CAS+Synchronized来保证并发安全进行实现

存储结构

jdk1.7

jdk1.7中采用Segment+HashEntry的方式进行实现

在这里插入图片描述

Segment：其继承于ReentrantLock类，从而使得Segment对象可以充当锁的角色。

Segment中包含HashBucket的数组，其可以守护其包含的若干个桶。

ConcurrentHashMap采用了分段锁，每个分段锁维护着几个桶，多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是Segment的个数）。

jdk1.8

在这里插入图片描述

JDK1.7使用分段锁机制来实现并发更新操作，核心类为Segment，它继承自重入锁ReentrantLock，并发程度与Segment数量相等。JDK1.8使用了CAS操作来支持更高的并发度，在CAS操作失败时使用内置锁synchronized。并且JDK1.8的实现也在链表过长时会转换为红黑树。

1.8中放弃了Segment臃肿的设计，取而代之的是采用Node数组+CAS+Synchronized来保证并发安全进行实现

添加元素：put

在这里插入图片描述

只让一个线程对散列表进行初始化！

获取元素：get

从顶部注释我们可以读到，get方法是不用加锁的，是非阻塞的。

Node节点是重写的，设置了volatile关键字修饰，致使它每次获取的都是最新设置的值

获取大小：size

每个Segment维护了一个count变量来统计该Segment中的键值对个数。

在执行size操作时，需要遍历所有Segment然后把count累计起来。

ConcurrentHashMap在执行size操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。

尝试次数使用RETRIES_BEFORE_LOCK定义，该值为2，retries初始值为-1，因此尝试次数为3。

如果尝试的次数超过3次，就需要对每个Segment加锁。

删除元素：remove

在这里插入图片描述

为什么用这么方式删除呢，细心的同学会发现上面定义的HashEntry的key和next都是final类型的，所以不能改变next的指向，所以又复制了一份指向删除的结点的next。

Collections.synchronizedMap()与ConcurrentHashMap的区别

参考：https://blog.csdn.net/lanxiangru/article/details/53495854

Collections.synchronizedMap()和Hashtable一样，实现上在调用map所有方法时，都对整个map进行同步，而ConcurrentHashMap的实现却更加精细，它对map中的所有桶加了锁，同步操作精确控制到桶，所以，即使在遍历map时，其他线程试图对map进行数据修改，也不会抛出ConcurrentModificationException。ConcurrentHashMap从类的命名就能看出，它是个HashMap。而Collections.synchronizedMap()可以接收任意Map实例，实现Map的同步。比如TreeMap。

总结

ConcurrentHashMap的高并发性主要来自于三个方面：

用分离锁实现多个线程间的更深层次的共享访问。用HashEntery对象的不变性来降低执行读操作的线程在遍历链表期间对加锁的需求。通过对同一个Volatile变量的写/读访问，协调不同线程间读/写操作的内存可见性。

LinkedHashMap

http://wiki.jikexueyuan.com/project/java-collection/linkedhashmap.html

https://segmentfault.com/a/1190000014319445

关键词

允许使用null值和null键此实现不是同步的（linkedlist，lilnkedhashset也不是同步的）维护着一个运行于所有条目的双向链表。定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。初始容量对遍历没有影响：遍历的双向链表，而不是散列表在访问顺序的情况下，使用get方法也是结构性的修改（会导致Fail-Fast）

概论

在这里插入图片描述

在这里插入图片描述

成员变量

该Entry除了保存当前对象的引用外，还保存了其上一个元素before和下一个元素after的引用，从而在哈希表的基础上又构成了双向链接列表。

构造器

在这里插入图片描述

通过源代码可以看出，在LinkedHashMap的构造方法中，实际调用了父类HashMap的相关构造方法来构造一个底层存放的table数组，但额外可以增加accessOrder这个参数，如果不设置默认为false，代表按照插入顺序进行迭代；当然可以显式设置为true，代表以访问顺序进行迭代。在构建新节点时，构建的是LinkedHashMap.Entry不再是Node.

获取元素：get

LinkedHashMap重写了父类HashMap的get方法，实际在调用父类getEntry()方法取得查找的元素后，再判断当排序模式accessOrder为true时，记录访问顺序，将最新访问的元素添加到双向链表的表头，并从原来的位置删除。

由于的链表的增加、删除操作是常量级的，故并不会带来性能的损失。

遍历元素

为啥注释说：初始容量对遍历没有影响？

因为它遍历的是LinkedHashMap内部维护的一个双向链表，而不是散列表(当然了，链表双向链表的元素都来源于散列表)

LinkedHashMap应用

http://wiki.jikexueyuan.com/project/java-collection/linkedhashmap-lrucache.html

LRU最近最少使用（访问顺序）

用这个类有两大好处：

它本身已经实现了按照访问顺序或插入顺序的存储LinkedHashMap本身有removeEldestEntry方法用于判断是否需要移除最不常读取的数，但是，原始方法默认不需要移除，我们需要override这样一个方法。

Java里面实现LRU缓存通常有两种选择：

使用LinkedHashMap自己设计数据结构，使用链表+HashMap

以下是使用LinkedHashMap实现的一个LRU缓存：

设定最大缓存空间MAX_ENTRIES为3；使用LinkedHashMap的构造函数将accessOrder设置为true，开启LRU顺序；覆盖removeEldestEntry()方法实现，在节点多于MAX_ENTRIES就会将最近最久未使用的数据移除。

实现详细代码请参考文章：补充知识点-缓存

FIFO（插入顺序）

还可以在插入顺序的LinkedHashMap直接重写下removeEldestEntry方法即可轻松实现一个FIFO缓存

TreeMap

关键词

红黑树非同步key不能为null实现了NavigableMap接口，而NavigableMap接口继承着SortedMap接口，是有序的（HahMap是Key无序的）TreeMap的基本操作containsKey、get、put和remove的时间复杂度是log(n)。适用于查找性能要求不那么高，反而对有序性要求比较高的应用场景使用Comparator或者Comparable来比较key是否相等与排序的问题

概览

在这里插入图片描述

获取元素：get

详细看：

https://segmentfault.com/a/1190000014345983#articleHeader4

总结：

如果在构造方法中传递了Comparator对象，那么就会以Comparator对象的方法进行比较。否则，则使用Comparable的compareTo(To)方法来比较。值得说明的是：如果使用的是compareTo(To)方法来比较，key一定是不能为null，并且得实现了Comparable接口的。即使是传入了Comparator对象，不用compareTo(To)方法来比较，key也是不能为null的

删除元素：remove

删除节点并且平衡红黑树

HashSet

http://wiki.jikexueyuan.com/project/java-collection/hashset.html

https://segmentfault.com/a/1190000014391402

关键词：

默认容量16，扩容两倍，加载因子0.75允许元素为null实现Set接口不保证迭代顺序非同步初始容量非常影响迭代性能底层实际上是一个HashMap实例>publicHashSet(){map=newHashMap<>();}

如果添加的是在HashSet中不存在的，则返回true；如果添加的元素已经存在，返回false。

对于HashSet中保存的对象，请注意正确重写其equals和hashCode方法，以保证放入的对象的唯一性。

HashSet和HashMap的区别

重要：

1.HashMap中使用键对象来计算hashcode值

2.HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false

在这里插入图片描述

TreeSet

关键词

实现NavigableSet接口可以实现排序功能底层实际上是一个TreeMap实例非同步不允许为null

LinkedHashSet

关键词

迭代是有序的允许为null底层实际上是一个HashMap+双向链表实例(其实就是LinkedHashMap)非同步性能比HashSet差一丢丢，因为要维护一个双向链表初始容量与迭代无关（与LinkedHashMap相同），因为LinkedHashSet迭代的是双向链表

总结Set

HashSet：

无序，允许为null，底层是HashMap(散列表+红黑树)，非线程同步

TreeSet：

有序，不允许为null，底层是TreeMap(红黑树),非线程同步

LinkedHashSet：

迭代有序，允许为null，底层是HashMap+双向链表，非线程同步

WeekHashMap

存储结构

WeakHashMap的Entry继承自WeakReference，被WeakReference关联的对象在下一次垃圾回收时会被回收。

WeakHashMap主要用来实现缓存，通过使用WeakHashMap来引用缓存对象，由JVM对这部分缓存进行回收。

ConcurrentCache

Tomcat中的ConcurrentCache使用了WeakHashMap来实现缓存功能。

ConcurrentCache采取的是分代缓存：

经常使用的对象放入eden中，eden使用ConcurrentHashMap实现，不用担心会被回收（伊甸园）；不常用的对象放入longterm，longterm使用WeakHashMap实现，这些老对象会被垃圾收集器回收。当调用get()方法时，会先从eden区获取，如果没有找到的话再到longterm获取，当从longterm获取到就把对象放入eden中，从而保证经常被访问的节点不容易被回收。当调用put()方法时，如果eden的大小超过了size，那么就将eden中的所有对象都放入longterm中，利用虚拟机回收掉一部分不经常使用的对象。

常见问题总结

Enumeration和Iterator接口的区别

Iterator替代了Enumeration，Enumeration是一个旧的迭代器了。

与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。

区别有三点：

Iterator的方法名比Enumeration更科学Iterator有fail-fast机制，比Enumeration更安全Iterator能够删除元素，Enumeration并不能删除元素

ListIterator有什么特点

ListIterator继承了Iterator接口，它用于遍历List集合的元素。ListIterator可以实现双向遍历,添加元素，设置元素

在这里插入图片描述

与Java集合框架相关的有哪些最好的实践

如果是单列的集合，我们考虑用Collection下的子接口ArrayList和Set。

如果是映射，我们就考虑使用Map

是否需要同步：去找线程安全的集合类使用迭代时是否需要有序(插入顺序有序)：去找Linked双向列表结构的是否需要排序(自然顺序或者手动排序)：去找Tree红黑树类型的(JDK1.8)估算存放集合的数据量有多大，无论是List还是Map，它们实现动态增长，都是有性能消耗的。在初始集合的时候给出一个合理的容量会减少动态增长时的消耗使用泛型，避免在运行时出现ClassCastException尽可能使用Collections工具类，或者获取只读、同步或空的集合，而非编写自己的实现。它将会提供代码重用性，它有着更好的稳定性和可维护性

参考

https://github.com/CyC2018/CS-Notes/blob/master/docs/notes/Java%20%E5%AE%B9%E5%99%A8.mdEckelB.Java编程思想[M].机械工业出版社,2002.JavaCollectionFrameworkIterator模式Java8系列之重新认识HashMapWhatisdifferencebetweenHashMapandHashtableinJava?Java集合之HashMapTheprincipleofConcurrentHashMapanalysis探索ConcurrentHashMap高并发性的实现机制HashMap相关面试题及其解答Java集合细节（二）：asList的缺陷JavaCollectionFramework–TheLinkedListClass

关注我

本人目前为后台开发工程师，主要关注Python爬虫，后台开发等相关技术。

原创博客主要内容：

笔试面试复习知识点手册Leetcode算法题解析（前150题）剑指offer算法题解析Python爬虫相关实战后台开发相关实战

同步更新以下几大博客：

Csdn：http://blog.csdn.net/qqxx6661拥有专栏：Leetcode题解（Java/Python）、Python爬虫开发知乎：https://www.zhihu.com/people/yang-zhen-dong-1/拥有专栏：码农面试助攻手册掘金：https://juejin.im/user/5b48015ce51d45191462ba55简书：https://www.jianshu.com/u/b5f225ca2376个人公众号：后端技术漫谈后端技术漫谈