1 LinkedHashMap
1.1 简介
LinkedHashMap 中的 “Linked” 实际上是指双向链表，并不是指解决散列冲突中的分离链表法。
LinkedHashMap 是继承于 HashMap 实现的哈希链表，它同时具备双向链表和散列表的特点。
LinkedHashMap 支持 2 种排序模式，这是通过构造器参数
accessOrder标记位控制的，表示是否按照访问顺序排序，默认为 false 按照插入顺序。 插入顺序（默认）：按照数据添加到 LinkedHashMap 的顺序排序，即 FIFO 策略；访问顺序：按照数据被访问（包括插入、更新、查询）的顺序排序，即 LRU 策略。在有序性的基础上，LinkedHashMap 提供了维护了淘汰数据能力，并开放了淘汰判断的接口
removeEldestEntry()。在每次添加数据时，会回调removeEldestEntry()接口，开发者可以重写这个接口决定是否移除最早的节点（在 FIFO 策略中是最早添加的节点，在 LRU 策略中是最早未访问的节点）；LinkedHashMap 也不考虑线程同步，也会存在线程安全问题。
1.2 源码分析
1.2.1 属性
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> {
// 头指针
transient LinkedHashMap.Entry<K,V> head;
// 尾指针
transient LinkedHashMap.Entry<K,V> tail;
// 是否按照访问顺序排序
final boolean accessOrder;
// 双向链表节点
static class Entry<K,V> extends HashMap.Node<K,V> {
// 前驱指针和后继指针（用于双向链表）
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next/*单链表指针（用于散列表的冲突解决）*/) {
super(hash, key, value, next);
}
}
}
LinkedHashMap 继承于 HashMap，并且新增 head 和 tail 指针指向链表的头尾节点（与 LinkedList 类似的头尾节点）；
1.2.2 构造器
LinkedHashMap 有 5 个构造方法，作用与 HashMap 的构造方法基本一致，区别只在于对 accessOrder 字段的初始化。
// 带初始容量和装载因子的构造方法
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
// 带初始容量的构造方法
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
// 无参构造方法
public LinkedHashMap() {
super();
accessOrder = false;
}
// 带 Map 的构造方法
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
// 带初始容量、装载因子和 accessOrder 的构造方法
// 是否按照访问顺序排序，为 true 表示按照访问顺序排序，默认为 false
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
1.3 基于 LinkedHashMap 实现 LRU 缓存
1.3.1 缓存淘汰算法
缓存是提高数据读取性能的通用技术，在硬件和软件设计中被广泛使用，例如 CPU 缓存、Glide 内存缓存，数据库缓存等。由于缓存空间不可能无限大，当缓存容量占满时，就需要利用某种策略将部分数据换出缓存，这就是缓存的替换策略 / 淘汰问题。常见缓存淘汰策略有：
- 1、随机策略： 使用一个随机数生成器随机地选择要被淘汰的数据块；
- 2、FIFO 先进先出策略： 记录各个数据块的访问时间，最早访问的数据最先被淘汰；
- 3、LRU （Least Recently Used）最近最少策略： 记录各个数据块的访问 “时间戳” ，最近最久未使用的数据最先被淘汰。与前 2 种策略相比，LRU 策略平均缓存命中率更高，这是因为 LRU 策略利用了 “局部性原理”：最近被访问过的数据，将来被访问的几率较大，最近很久未访问的数据，将来访问的几率也较小；
- 4、LFU （Least Frequently Used）最不经常使用策略： 与 LRU 相比，LFU 更加注重使用的 “频率” 。LFU 会记录每个数据块的访问次数，最少访问次数的数据最先被淘汰。但是有些数据在开始时使用次数很高，以后不再使用，这些数据就会长时间污染缓存。可以定期将计数器右移一位，形成指数衰减。
1.3.2 LRU变形
在标准的 LRU 算法上还有一些变型实现，这是因为 LRU 算法本身也存在一些不足。例如，当数据中热点数据较多时，LRU 能够保证较高的命中率。但是当有偶发的批量的非热点数据产生时，就会将热点数据寄出缓存，使得缓存被污染。因此，LRU 也有一些变型：
- LRU-K： 提供两个 LRU 队列，一个是访问计数队列，一个是标准的 LRU 队列，两个队列都按照 LRU 规则淘汰数据。当访问一个数据时，数据先进入访问计数队列，当数据访问次数超过 K 次后，才会进入标准 LRU 队列。标准的 LRU 算法相当于 LRU-1；
- Two Queue： 相当于 LRU-2 的变型，将访问计数队列替换为 FIFO 队列淘汰数据数据。当访问一个数据时，数据先进入 FIFO 队列，当第 2 次访问数据时，才会进入标准 LRU 队列；
- Multi Queue： 在 LRU-K 的基础上增加更多队列，提供多个级别的缓冲。
1.3.3 如何实现 LRU 缓存淘汰算法
我们可以定义一个缓存系统的基本操作：
- 操作 1 - 添加数据： 先查询数据是否存在，不存在则添加数据，存在则更新数据，并尝试淘汰数据；
- 操作 2 - 删除数据： 先查询数据是否存在，存在则删除数据；
- 操作 3 - 查询数据： 如果数据不存在则返回 null；
- 操作 4 - 淘汰数据： 添加数据时如果容量已满，则根据缓存淘汰策略一个数据。
我们发现，前 3 个操作都有 “查询” 操作， 所以缓存系统的性能主要取决于查找数据和淘汰数据是否高效。
基于双向链表 + 散列表： 使用双向链表可以将淘汰数据的时间复杂度降低为 O(1)，但是查询数据的时间复杂度还是 O(n)，我们可以在双向链表的基础上增加散列表，将查询操作的时间复杂度降低为 O(1)。
- 查询数据：通过散列表定位数据，时间复杂度为 O(1)；
- 淘汰数据：直接淘汰链表尾节点，时间复杂度为 O(1)。
这种数据结构就叫 “哈希链表或链式哈希表”
1.3.4 实现逻辑
理解了 LinkedHashMap 维护插入顺序和访问顺序的原理后，相信你已经知道如何实现 LRU 缓存了。
- 首先，我们已经知道，LinkedHashMap 支持 2 种排序模式，这是通过构造器参数
accessOrder标记位控制的。所以，这里我们需要将accessOrder设置为 true 表示使用 LRU 模式的访问顺序排序。 - 其次，我们不需要实现淘汰数据的逻辑，只需要重写淘汰判断接口
removeEldestEntry()，当缓存数量大于缓存容量时返回 true，表示移除最早的节点。
public class MaxSizeLruCacheDemo extends LinkedHashMap {
private int maxElements;
public LRUCache(int maxSize) {
super(maxSize, 0.75F, true);
maxElements = maxSize;
}
protected boolean removeEldestEntry(java.util.Map.Entry eldest) {
// 超出容量
return size() > maxElements;
}
}
2 TreeMap
2.1 排序
2.1.1 Comparable
实现该接口需要一个实体对象，然后重写其compareTo()，我们来看例子：
// 定义一个Student对象
class Student implements Comparable<Student> {
public int id;
public String name;
public int age;
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
/**
* 对比方法
*/
@Override
public int compareTo(Student o) {
// 按照年龄从小到大的排序方式
return age - o.age;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
// 小案例
ArrayList<Student> students = new ArrayList<Student>(6) {{
add(new Student(1, "张三", 20));
add(new Student(2, "里斯", 18));
add(new Student(3, "王五", 38));
add(new Student(4, "赵柳", 10));
add(new Student(5, "天气", 77));
}};
// 排序前的输出
System.out.println("排序前的输出:");
System.out.println(students);
System.out.println("================");
// 排序操作
Collections.sort(students);
System.out.println("排序后的输出:");
System.out.println(students);
/**
排序前的输出
[Student{id=1, name='张三', age=20}, Student{id=2, name='里斯', age=18}, Student{id=3, name='王五', age=38}, Student{id=4, name='赵柳', age=10}, Student{id=5, name='天气', age=77}]
================
[Student{id=4, name='赵柳', age=10}, Student{id=2, name='里斯', age=18}, Student{id=1, name='张三', age=20}, Student{id=3, name='王五', age=38}, Student{id=5, name='天气', age=77}]
**/
2.1.2 Comparator
这种方式是通过外部类的方式进行编写，还是上面的代码，我们改一些地方：
Collections.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 按照ID降序排序
return (int) (o2.id - o1.id);
}
});
/**
排序前的输出:
[Student{id=1, name='张三', age=20}, Student{id=2, name='里斯', age=20}, Student{id=3, name='王五', age=38}, Student{id=4, name='赵柳', age=10}, Student{id=5, name='天气', age=77}]
================
排序后的输出:
[Student{id=5, name='天气', age=77}, Student{id=4, name='赵柳', age=10}, Student{id=3, name='王五', age=38}, Student{id=2, name='里斯', age=20}, Student{id=1, name='张三', age=20}]
**/
2.2 树
2.2.1 二叉树
二叉树是树形结构中的一种重要类型，是我们在数据结构中最常用的树结构之一，每个节点下最多只有两个子节点
2.2.2 二叉搜索树
顾名思义，二叉搜索树是以二叉树来组织的，对比二叉树，拥有以下特性：
- 每个节点下最多只拥有两个节点
- 采用左小右大的规则插入元素节点，如果相等，那么插入到右边
- 所以在遍历节点的时候可以采用 二分法 来减少元素的查询
2.2.1 平衡树
也称AVL树，是基于二叉搜索树的一种扩展，也就是说拥有二叉搜索树的全部特性。二叉搜索树存在缺点：
- 数据插入方式，容易造成两边节点，一边长一边短的问题，这样在通过 二分法来遍历元素的时候也存在性能问题
AVL树针对这一情况进行了改进：
- AVL树会对不平衡的树进行一个旋转，优化整个数据结构，保证整个树的平衡，保证整个二分查找的效率
- 旋转规则：每个节点的左右子节点的高度之差的绝对值最多为1， 即平衡因子为范围[-1,1]
2.2.1 红黑树
基于平衡树的一种演进，也存在旋转操作保持二叉树的平衡，同时在此基础上添加变色操作，拥有如下特性：
- 节点是红色或者黑色
- 根节点是黑色，每个叶子节点（NUIL节点）是黑色的
- 如果一个节点是红色的，那么其子节点就是黑色的（也就是说不能存在连续的红色节点）
- 从任意节点到其每个叶子的所有路径都包含相同数目的黑色节点
- 最长路径不超过最短路径的2倍
2.3 源码分析
2.3.1 简介
基于红黑树方式实现的Map
按照自然排序或者是指定的方式排序，这取决于我们所使用的的构造方法，所以说，TreeMap是有序的，我们可以指定其排序方式
TreeMap是线程不安全的，如果想要实现，需要对TreeMap进行包装
SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));
2.3.2 构造方法
public TreeMap() {
comparator = null;
}
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
下面我们来具体看看我们如何使用TreeMap的
TreeMap<String, String> treeMap = new TreeMap<>();
new TreeMap<String, Long>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return 0;
}
});
如果我们没有传入 比较器，默认为null，那么我们需要明白：传入的Key必须要实现Comparable接口的类型，这一点我们在**put()**方法中会跟源码说明
2.3.3 Put
节点类
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
Entry<K,V> left;
Entry<K,V> right;
Entry<K,V> parent;
boolean color = BLACK;
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
}
TreeMap底层是采用红黑树的结构来存储数据，那么对应到代码中的实现就是上面的样子。下面我们来看具体是如何添加元素的
public V put(K key, V value) {
Entry<K,V> t = root;
// 根节点
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
// 比较器比较 得到当前节点应该归属的父节点
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
// 赋值操作
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
// 变色，旋转
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
总结一下，可以分为四步来进行操作：
- 判断如果当前根节点为null，那么当前插入的第一个元素就为根节点元素
- 如果存在根节点，那么再添加元素的时候根据排序器进行对比，验证当前元素应该在左侧还是在右侧，如果对比为0，那么说明当前元素存在于TreeMap中，直接将其进行覆盖。这里也就说明了一个问题：在TreeMap中，不会存在重复元素
- 找到自己所对应的位置，然后进行指针引用
- 节点变色操作和旋转操作
2.3.4 Get
Entry<K,V> p = getEntry(key);
final Entry<K,V> getEntry(Object key) {
// Offload comparator-based version for sake of performance
if (comparator != null)
return getEntryUsingComparator(key);
if (key == null)
throw new NullPointerException();
// 默认构造器
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
Entry<K,V> p = root;
while (p != null) {
// 不断对比，如果==0，那么就是当前需要的Entry
int cmp = k.compareTo(p.key);
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
return null;
}
// 自定义排序方式
final Entry<K,V> getEntryUsingComparator(Object key) {
@SuppressWarnings("unchecked")
K k = (K) key;
Comparator<? super K> cpr = comparator;
if (cpr != null) {
Entry<K,V> p = root;
while (p != null) {
// 不断对比，如果==0，那么就是当前需要的Entry
int cmp = cpr.compare(k, p.key);
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
}
return null;
}
该方法还是比较简单的，也就是在while()循环中通过比较器进行对比
3 HashTable
3.1 简介
和HashMap一样，Hashtable也是一个散列表，它存储的内容是键值对(key-value)映射, 重要特点如下:
- 存储key-value键值对格式
- 是无序的
- 底层通过数组+链表的方式实现
- 通过synchronized关键字实现线程安全
- key、value都不可以为null（为null时将抛出NullPointerException）
3.2 实现原理
和HashMap相似，Hashtable底层采用数组+链表的数据结构，根据key找到数组对应的桶，相同的key通过链表维护，当数组桶的使用到达阈值后，会进行动态扩容。但是和HashMap不同的是，链表不会转换为红黑树。
3.3 成员变量
// 内部采用Entry数组存储键值对数据，Entry实际为单向链表的表头
private transient Entry<?,?>[] table;
// HashTable里键值对个数
private transient int count;
// 扩容阈值，当超过这个值时，进行扩容操作，计算方式为：数组容量*加载因子
private int threshold;
// 加载因子
private float loadFactor;
// 修改次数，用于快速失败机制
private transient int modCount = 0;
3.4 构造函数
// 设置指定容量和加载因子，初始化HashTable
public Hashtable(int initialCapacity, float loadFactor) {
// 非法参数校验
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
// 非法参数校验
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
if (initialCapacity==0)
// 容量最小为1
initialCapacity = 1;
this.loadFactor = loadFactor;
// 初始化数组
table = new Entry<?,?>[initialCapacity];
// 初始扩容阈值
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
// 设置指定容量初始HashTable，加载因子为0.75
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
// 手动指定数组初始容量为11，加载因子为0.75
public Hashtable() {
this(11, 0.75f);
}
3.5 Put
// 方法synchronized修饰，线程安全
public synchronized V put(K key, V value) {
// 如果value为空，直接空指针
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
// 得到key的哈希值
int hash = key.hashCode();
// 得到该key存在到数组中的下标
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
// 得到该下标对应的Entry
Entry<K,V> entry = (Entry<K,V>)tab[index];
// 如果该下标的Entry不为null，则进行链表遍历
for(; entry != null ; entry = entry.next) {
// 遍历链表，如果存在key相等的节点，则替换这个节点的值，并返回旧值
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
// 如果数组下标对应的节点为空，或者遍历链表后发现没有和该key相等的节点，则执行插入操作
addEntry(hash, key, value, index);
return null;
}
private void addEntry(int hash, K key, V value, int index) {
// 修改次数+1
modCount++;
Entry<?,?> tab[] = table;
// 判断是否需要扩容
if (count >= threshold) {
// 如果count大于等于扩容阈值，则进行扩容
rehash();
tab = table;
// 扩容后，重新计算该key在扩容后table里的下标
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
@SuppressWarnings("unchecked")
// 采用头插的方式插入，index位置的节点为新节点的next节点
// 新节点取代inde位置节点
Entry<K,V> e = (Entry<K,V>) tab[index];
tab[index] = new Entry<>(hash, key, value, e);
// count+1
count++;
}
3.5.1 扩容
protected void rehash() {
// 暂存旧的table和容量
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// 新容量为旧容量的2n+1倍
int newCapacity = (oldCapacity << 1) + 1;
// 判断新容量是否超过最大容量
if (newCapacity - MAX_ARRAY_SIZE > 0) {
// 如果旧容量已经是最大容量大话，就不扩容了
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
// 新容量最大值只能是MAX_ARRAY_SIZE
newCapacity = MAX_ARRAY_SIZE;
}
// 用新容量创建一个新Entry数组
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
// 模数+1
modCount++;
// 重新计算下次扩容阈值
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
// 将新Entry数组赋值给table
table = newMap;
// 遍历数组和链表，进行新table赋值操作
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}
扩容机制依赖两个成员变量，初始容量 和 加载因子。他们可以通过构造函数设置。
容量是值哈希表中桶的数量，初始容量就是哈希表创建时的容量。当容量达到阈值的时候，会进行扩容操作，每次扩容是原来容量的2倍加1，然后重新为hashtable中的每个元素重新分配桶的位置。
那阈值是多少呢，Hashtable的阈值，用于判断是否需要调整Hashtable的容量，等于"Hashtable当前的容量*加载因子"。
通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间。
3.6 Get
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
// 根据key哈希得到index，遍历链表取值
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}
3.7 总结
下面在总结下Hashtable和HashMap的区别：
线程是否安全：HashMap是线程不安全的，HashTable是线程安全的；HashTable内部的方法基本都经过 synchronized修饰; 如果想要线程安全的Map容器建议使用ConcurrentHashMap,性能更好。
对Null key 和Null value的支持：HashMap中，null可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为null；HashTable中key和value都不能为null，否则抛出空指针异常；
初始容量大小和每次扩充容量大小的不同：创建时如果不指定容量初始值，Hashtable默认的初始大小为11，之后每次扩容，容量变为原来的2n+1。HashMap默认的初始化大小为16。之后每次扩充，容量变为原来的2倍；创建时如果给定了容量初始值，那么Hashtable会直接使用你给定的大小，而HashMap会将其扩充 为2的幂次方大小。
底层数据结构：JDK1.8及以后的HashMap在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树，以减少搜索时间，Hashtable没有这样的机制。
