常见的Map类型有以下几种：
HashMap：无序、访问速度快、key不允许重复（只允许存在一个null key）
LinkedHashMap：有序、HashMap 子类
TreeMap：
TreeMap 中保存的记录会根据 Key 排序（默认为升序排序），
因此使用 Iterator 遍历时得到的记录是排过序的
因为需要排序，所以TreeMap 中的 key 必须实现 Comparable 接口，
否则会报 ClassCastException 异常
TreeMap 会按照其 key 的 compareTo 方法来判断 key 是否重复
Hashtable：
一个遗留类，线程安全，与 HashMap 类似
当不需要线程安全时，选择 HashMap 代替
当需要线程安全时，使用 ConcurrentHashMap 代替
首先先了解一下 HashMap 内部的一些主要特点：
使用哈希表（散列表）来进行数据存储，并使用链地址法来解决冲突
当链表长度大于等于 8 时，将链表转换为红黑树来存储
每次进行二次幂的扩容，即扩容为原容量的两倍
HashMap 有以下几个字段：
Node[] table：存储数据的哈希表；初始长度 length = 16（DEFAULT_INITIAL_CAPACITY），扩容时容量为原先的两倍（n * 2）
final float loadFactor：负载因子，确定数组长度与当前所能存储的键值对最大值的关系；不建议轻易修改，除非情况特殊
int threshold：所能容纳的 key-value 对极限 ；threshold = length * factor，当存在的键值对大于该值，则进行扩容
int modCount：HashMap 结构修改次数（例如每次 put 新值使则自增 1）
int size：当前 key-value 个数
static class Node implements Map.Entry {
final int hash;
final K key;
V value;
Node next;
Node(int hash, K key, V value, Node next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this) return true;
if (o instanceof Map.Entry) {
Map.Entry e = (Map.Entry)o;
if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
capacity：当前数组容量，始终保持 2^n，可以扩容，扩容后数组大小为当前的2倍。
threshold：扩容的阈值，等于 capacity * loadFactor = 16*0.75=12
Returns a power of two size for the given target capacity.
// 当cap = 10时
static final int tableSizeFor(int cap) {
int n = cap - 1; //9 = 0000 1001
//>>>这个是无符号右移
n |= n >>> 1; //n=n|(n>>>1)=0000 1001 | 0000 0100 = 0000 1101
n |= n >>> 2;//n=n|(n>>>2)=0000 1101 | 0000 0011 = 0000 1111
n |= n >>> 4;//n=n|(n>>>4)=0000 1111 | 0000 0000 = 0000 1111
n |= n >>> 8;//n=n|(n>>>8)=0001 1111 | 0000 0000 = 0000 1111
n |= n >>> 16;//n=n|(n>>>8)=0001 1111 | 0000 0000 = 0000 1111
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;//16
}
// 当cap = 17时
static final int tableSizeFor(int cap) {
int n = cap - 1; //16 = 0001 0000
//>>>这个是无符号右移
n |= n >>> 1; //n=n|(n>>>1)=0001 0000 | 0000 1000 = 0001 1000
n |= n >>> 2;//n=n|(n>>>2)=0001 1000 | 0000 0110 = 0001 1110
n |= n >>> 4;//n=n|(n>>>4)=0001 1110 | 0000 0001 = 0001 1111
n |= n >>> 8;//n=n|(n>>>8)=0001 1111 | 0000 0000 = 0001 1111
n |= n >>> 16;//n=n|(n>>>8)=0001 1111 | 0000 0000 = 0001 1111
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;//32
}
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
transient Node[] table;
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
HashMap.Node[] tab;
HashMap.Node p;
int n, I;
if ((tab = table) == null || (n = tab.length) == 0)
//初始化哈希表,这里很显然运用了 lazy-load 原则，当哈希表被首次使用时，才进行初始化
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//通过哈希值找到对应的位置，如果该位置还没有元素存在，直接插入
tab[i] = newNode(hash, key, value, null);
else {
HashMap.Node e;
K k;
//如果该位置的元素的 key 与之相等，则直接到后面重新赋值
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof HashMap.TreeNode)
//如果当前节点为树节点，则将元素插入红黑树中
e = ((HashMap.TreeNode) p).putTreeVal(this, tab, hash, key, value);
else {
//否则一步步遍历链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//插入元素到链尾
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1)
//元素个数大于等于 8，改造为红黑树
treeifyBin(tab, hash);
break;
}
//如果该位置的元素的 key 与之相等，则重新赋值
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//前面当哈希表中存在当前key时对e进行了赋值，这里统一对该key重新赋值更新
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//检查是否超出 threshold 限制，是则进行扩容
if (++size > threshold) resize();
afterNodeInsertion(evict);
return null;
}
final Node[] resize() {
Node[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;//16，32，64
int oldThr = threshold;//12，24，48
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold, 24,48....
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;//16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node[] newTab = (Node[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode)e).split(this, newTab, j, oldCap);
else { // preserve order
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
面试问题
HashMap和ConcurrentHashMap的区别：
1.HashMap不是线程安全的，而ConcurrentHashMap是线程安全的。
2.ConcurrentHashMap采用锁分段技术，将整个Hash桶进行了分段segment，也就是将这个大的数组分成了几个小的片段segment，而且每个小的片段segment上面都有锁存在，那么在插入元素的时候就需要先找到应该插入到哪一个片段segment，然后再在这个片段上面进行插入，而且这里还需要获取segment锁。
3.ConcurrentHashMap让锁的粒度更精细一些，并发性能更好。
jdk1.7 hashmap多线程情况下为什么可能产生环链。
原因是因为在进行扩容的时候，采用了头插法。jdk1.8采用尾插法没这个问题。
红黑树的原理以及为什么元素个数大于等于 8，改造为红黑树