Java集合类工作原理及实现

集合类的实现原理

LRUCache原理

1、LruCache 内部使用 LinkedHashMap 实现，所以 LruCache 保存的是键值对
2、LruCache 本身对缓存项是强引用
3、LruCache 的读写是线程安全的，内部加了 synchronized。也就是 put(K key, V value) 和 get(K key) 内部有 synchronized
4、key 和 value 不接受 null 。所以如果 get 到了 null ，那就说明是没有缓存
5、Override sizeOf(K key, V value) 方法
6、根据需要Override entryRemoved(boolean evicted, K key, V oldValue, V newValue) 和 create(K key) 方法

核心算法
map：存放数据的集合    new LinkedHashMap(0, 0.75f, true);
size：当前LruCahce的内存占用大小
maxSize：Lrucache的最大容量
putCount：put的次数
createCount：create的次数
evictionCount：回收的次数
hitCount：命中的次数
missCount：丢失的次数

Lru是最近最少使用算法的简称，意思呢就是查询出最近的时间使用次数最少的那个对象。设置为true的时候，如果对一个元素进行了操作(put、get)，就会把那个元素放到集合的最后，设置为false的时候，无论怎么操作，集合元素的顺序都是按照插入的顺序来进行存储的。
算法核心：当内容容量达到最大值的时候，只需要移除这个集合的前面的元素直到集合的容量足够存储数据的时候就可以了。

HashMap

图解HashMap(一)

图解HashMap(二)

HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体

image.png

简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据 hash 算法来决定其在数组中的存储位置，在根据 equals 方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry 时，也会根据 hash 算法找到其在数组中的存储位置，再根据 equals 方法从该位置上的链表中取出该Entry。

扩容:当 HashMap 中的元素个数超过数组大小 loadFactor时，就会进行数组扩容，loadFactor的默认值为 0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为 16，那么当 HashMap 中元素个数超过 160.75=12 的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知 HashMap 中元素的个数，那么预设元素的个数能够有效的提高 HashMap 的性能。

Fail-Fast 机制：HashMap 不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了 map，那么将抛出 ConcurrentModificationException，这就是所谓 fail-fast 策略。
例如：当某一个线程 A 通过 iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程 A 访问集合时，就会抛出ConcurrentModificationException 异常，产生 fail-fast 事件。
实现原理：判断 modCount 跟 expectedModCount 是否相等，如果不相等就表示已经有其他线程修改了 Map。
解决方案：建议使用“java.util.concurrent 包下的类”去取代“java.util 包下的类”

遍历方式：
第一种：

　  Map map = new HashMap();
　　Iterator iter = map.entrySet().iterator();
　　while (iter.hasNext()) {
　　Map.Entry entry = (Map.Entry) iter.next();
　　Object key = entry.getKey();
　　Object val = entry.getValue();
    }

效率高,以后一定要使用此种方式
第二种：

Map map = new HashMap();
　　Iterator iter = map.keySet().iterator();
　　while (iter.hasNext()) {
　　Object key = iter.next();
　　Object val = map.get(key);
　　}

效率低,以后尽量少使用！

ArrayMap

参考：
面试必备：ArrayMap源码解析

image

内部结构：
它的内部实现是基于两个数组。
一个int[]数组，用于保存每个item的hashCode.
一个Object[]数组，保存key/value键值对。容量是上一个数组的两倍
优点：
和HashMap相比，它不仅有扩容功能，在删除时，如果集合剩余元素少于一定阈值，还有收缩（shrunk）功能。减少空间占用。
缺点：
但是它不适合大容量的数据存储。存储大量数据时，它的性能将退化至少50%。比传统的HashMap时间效率低。因为其会对key从小到大排序，使用二分法查询key对应在数组中的下标。在添加、删除、查找数据的时候都是先使用二分查找法得到相应的index，然后通过index来进行添加、查找、删除等操作。

适用场景：
1、数据量不大
2、空间比时间重要
3、需要使用Map
4、在Android平台，相对来说，内存容量更宝贵。而且数据量不大。所以当需要使用key是Object类型的Map时，可以考虑使用ArrayMap来替换HashMap

ConcurrentHashMap

ConcurrentHashMap 的成员变量中，包含了一个 Segment 的数组（final Segment[] segments;），而 Segment 是 ConcurrentHashMap 的内部类，然后在 Segment 这个类中，包含了一个 HashEntry 的数组（transient volatile HashEntry[] table;）。而 HashEntry 也是 ConcurrentHashMap 的内部类。HashEntry 中，包含了 key 和 value 以及 next 指针（类似于 HashMap 中 Entry），所以 HashEntry 可以构成一个链表。

所以通俗的讲，ConcurrentHashMap 数据结构为一个 Segment 数组，Segment 的数据结构为 HashEntry 的数组，而 HashEntry 存的是我们的键值对，可以构成链表。

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

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

使用分离锁，减小了请求 同一个锁的频率。

通过 HashEntery 对象的不变性及对同一个 Volatile 变量的读 / 写来协调内存可见性，使得 读操作大多数时候不需要加锁就能成功获取到需要的值。由于散列映射表在实际应用中大多数操作都是成功的 读操作，所以 2 和 3 既可以减少请求同一个锁的频率，也可以有效减少持有锁的时间。通过减小请求同一个锁的频率和尽量减少持有锁的时间 ，使得 ConcurrentHashMap 的并发性相对于 HashTable 和用同步包装器包装的 HashMap有了质的提高。

SparseArray

SparseArray 的使用及实现原理
面试必备：SparseArray源码解析
内部结构：
它的内部实现也是基于两个数组。一个int[]数组mKeys，用于保存每个item的key，key本身就是int类型，所以可以理解hashCode值就是key的值.一个Object[]数组mValues，保存value。容量和key数组的一样。
类似ArrayMap,它扩容的更合适，扩容时只需要数组拷贝工作，不需要重建哈希表

优势：

• 避免了基本数据类型的装箱操作
• 不需要额外的结构体，单个元素的存储成本更低
• 数据量小的情况下，随机访问的效率更高

有优点就一定有缺点

• 插入操作需要复制数组，增删效率降低
• 数据量巨大时，复制数组成本巨大，gc()成本也巨大
• 数据量巨大时，查询效率也会明显下降

HashSet

对于 HashSet 中保存的对象，请注意正确重写其 equals 和 hashCode 方法，以保证放入的对象的唯一性。这两个方法是比较重要的，希望大家在以后的开发过程中需要注意一下。

image.png

Hashtable

HashMap和HashTab的异同

1.HashTable 基于 Dictionary 类，而 HashMap 是基于 AbstractMap。Dictionary 是任何可将键映射到相应值的类的抽象父类，而 AbstractMap 是基于 Map 接口的实现，它以最大限度地减少实现此接口所需的工作。

2.HashMap 的 key 和 value 都允许为 null，而 Hashtable 的 key 和 value 都不允许为 null。HashMap 遇到 key 为 null 的时候，调用 putForNullKey 方法进行处理，而对 value 没有处理；Hashtable遇到 null，直接返回 NullPointerException。

3.Hashtable 方法是同步，而HashMap则不是。我们可以看一下源码，Hashtable 中的几乎所有的 public 的方法都是 synchronized 的，而有些方法也是在内部通过 synchronized 代码块来实现。所以有人一般都建议如果是涉及到多线程同步时采用 HashTable，没有涉及就采用 HashMap，但是在 Collections 类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的 Map 对象，并把它作为一个封装的对象来返回。

LinkedHashMap

参考：
面试必备：LinkedHashMap源码解析（JDK8）
彻头彻尾理解 LinkedHashMap
图解LinkedHashMap原理
# LinkedHashMap就这么简单【源码剖析】

image

本质上，HashMap和双向链表合二为一即是LinkedHashMap。
LinkedHashMap 是一个关联数组、哈希表，它是线程不安全的，允许key为null,value为null。
它继承自HashMap，实现了Map接口。其内部还维护了一个双向链表，在每次插入数据，或者访问、修改数据时，会增加节点、或调整链表的节点顺序。以决定迭代时输出的顺序。

默认情况，遍历时的顺序是按照插入节点的顺序。这也是其与HashMap最大的区别。
也可以在构造时传入accessOrder参数，使得其遍历顺序按照访问的顺序输出。

因继承自HashMap,所以HashMap上文分析的特点，除了输出无序，其他LinkedHashMap都有，比如扩容的策略，哈希桶长度一定是2的N次方等等。
LinkedHashMap在实现时，就是重写override了几个方法。以满足其输出序列有序的需求。

LinkedHashMap是Hash表和链表的实现，并且依靠着双向链表保证了迭代顺序是插入的顺序
其实 LinkedHashMap 几乎和 HashMap 一样：从技术上来说，不同的是它定义了一个 Entry header，这个 header 不是放在 Table 里，它是额外独立出来的。LinkedHashMap 通过继承 hashMap 中的 Entry,并添加两个属性 Entry before,after,和 header 结合起来组成一个双向链表，来实现按插入顺序或访问顺序排序。
HashMap,LinkedHashMap,TreeMap的区别

LinkedHashSet

• LinkedHashSet 是 Set 的一个具体实现，其维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可为插入顺序或是访问顺序。
• LinkedHashSet 继承与 HashSet，并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基于 Hashmap 实现一样，不过还是有一点点区别的（具体的区别大家可以自己去思考一下）。
• 如果我们需要迭代的顺序为插入顺序或者访问顺序，那么 LinkedHashSet 是需要你首先考虑的。

ArrayList

参考：
面试必备：ArrayList源码解析（JDK8）

ArrayList 是一个动态数组，它是线程不安全的，允许元素为null。其底层数据结构依然是数组，它实现了List, RandomAccess, Cloneable, java.io.Serializable接口，其中RandomAccess代表了其拥有随机快速访问的能力，ArrayList可以以O(1)的时间复杂度去根据下标访问元素。
因其底层数据结构是数组，所以可想而知，它是占据一块连续的内存空间（容量就是数组的length），所以它也有数组的缺点，空间效率不高。
由于数组的内存连续，可以根据下标以O1的时间读写(改查)元素，因此时间效率很高。
当集合中的元素超出这个容量，便会进行扩容操作。扩容操作也是ArrayList 的一个性能消耗比较大的地方，所以若我们可以提前预知数据的规模，应该通过public ArrayList(int initialCapacity) {}构造方法，指定集合的大小，去构建ArrayList实例，以减少扩容次数，提高效率。

LinkedList

参考:
面试必备：LinkedList源码解析（JDK8）

LinkedList 是线程不安全的，允许元素为null的双向链表。其底层数据结构是链表，它实现List, Deque, Cloneable, java.io.Serializable接口，它实现了Deque,所以它也可以作为一个双端队列。和ArrayList比，没有实现RandomAccess所以其以下标，随机访问元素速度较慢。
因其底层数据结构是链表，所以可想而知，它的增删只需要移动指针即可，故时间效率较高。不需要批量扩容，也不需要预留空间，所以空间效率比ArrayList高。
缺点就是需要随机访问元素时，时间效率很低，虽然底层在根据下标查询Node的时候，会根据index判断目标Node在前半段还是后半段，然后决定是顺序还是逆序查询，以提升时间效率。不过随着n的增大，总体时间效率依然很低。
当每次增、删时，都会修改modCount。

最后通过一篇对比文章来总结一下java集合类：
关于HashMap，HashTable， HashSet，TreeMap，CurrentHashMap 区别和联系

理论基础：
到底什么是hash呢?hash碰撞？为什么HashMap的初始容量是16？
什么是 hash？
常见的hash算法及其原理
神奇的算法：HashMap(哈希映射)
HashMap中的为什么hash的长度为2的幂而&位必须为奇数

static int indexFor(int h, int length) {  
    return h & (length-1);  
} 

一文读懂HashMap

1.7和1.8的HashMap的不同点
（1）JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法，那么为什么要这样做呢？因为JDK1.7是用单链表进行的纵向延伸，当采用头插法就是能够提高插入的效率，但是也会容易出现逆序且环形链表死循环问题。但是在JDK1.8之后是因为加入了红黑树使用尾插法，能够避免出现逆序且链表死循环的问题。

（2）扩容后数据存储位置的计算方式也不一样： 1. 在JDK1.7的时候是直接用hash值和需要扩容的二进制数进行&（这里就是为什么扩容的时候为啥一定必须是2的多少次幂的原因所在，因为如果只有2的n次幂的情况时最后一位二进制数才一定是1，这样能最大程度减少hash碰撞）（hash值 & length-1） 。 2. 而在JDK1.8的时候直接用了JDK1.7的时候计算的规律，也就是扩容前的原始位置+扩容的大小值=JDK1.8的计算方式，而不再是JDK1.7的那种异或的方法。但是这种方式就相当于只需要判断Hash值的新增参与运算的位是0还是1就直接迅速计算出了扩容后的储存方式。
（3）JDK1.7的时候使用的是数组+ 单链表的数据结构。但是在JDK1.8及之后时，使用的是数组+链表+红黑树的数据结构（当链表的深度达到8的时候，也就是默认阈值，就会自动扩容把链表转成红黑树的数据结构来把时间复杂度从O（N）变成O（logN）提高了效率）。

HashMap为何从头插入改为尾插入

头插法和尾插法图文并茂