一直想看集合的源码，奈何总觉得时间不够用，第一次看，先大概做个笔记，参考了一些博客和书，后面继续更新。。。
零，总括
Map是用来存储键值对的数据结构，在数组中通过数组下标来对其内容进行索引。从java源码来看，java是先实现了Map，然后通过包装一个所有value为null的Map就实现了Set集合
1.Hashtable
继承Dictionary，方法被synchronized修饰，so是一个线程安全的实现，性能略低于HashMap，使用的迭代器是Enumeration，会在别的线程修改元素的时候抛出ConcurrentModificationException异常
2.HashMap
根据键的HashCode值存储数据，使用的数据结构是链表散列（数据+链表），访问速度很快，特点是线程不安全、允许空键值。冲突解决方法是链地址法（桶的概念，对于Entry数组而言，数组每个元素存储的是链表，一个链表就是一个桶，使用addEntry方法添加新元素时总是将新元素添加在链表的表头）
扩容：当HashMap.size>=Capacity*LoadFactor时调整大小，默认扩展为两倍
3.ConcurrentHashMap
产生于JDK1.5之后，用于替代Hashtable的线程安全的HashMap。ConcurrentHashMap在线程安全的基础上提供了更好的写并发能力，但同时降低了对读一致性的要求，大量利用了volatile、final、CAS等lock-free技术来减少锁竞争对于性能的影响。在JDK6、7、8的实现都不一样，在JDK8中，利用CAS来替代之前的segment概念，底层用数组+链表+红黑树的方法实现，增加了很多辅助类来支持并发
一，Hashtable
1.继承的是Dicitionary类，实现了Map、Cloneable、Serializable接口
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable2.几个属性
private transient Entry<?,?>[] table;//实现Hashtable借助的数组，默认大小为11
private transient int count;//记录table数组中存储元素的个数
private int threshold;//扩容的门限，即如果table中存储的元素个数大于threshold，则扩大数组table的大小
private float loadFactor;//加载因子，默认为0.75f3.构造函数
有如下等：
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
/**
* Constructs a new, empty hashtable with a default initial capacity (11)
* and load factor (0.75).
*/
public Hashtable() {
this(11, 0.75f);
}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)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry<?,?>[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
4.put函数
思想：首先检查value是否为null，若是，则抛异常。根据key的hashCode找到此元素的存储位置index，如果位置index已经有元素链表了，则在此链表中，寻找是否有key已经存在，如果存在更新value值，若不存在则将此节点插入
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
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;
}5.addEntry，给数组table的index位置添加元素
思想：首先检查数组table元素个数是否大于扩容门限，如果大于则扩容，扩容之后，重新获取key的hashCode，并根据hashCode计算要存储的位置index，最后将要存储的数据存储到table[index]中。如果table[index]中已经有其他元素，那么同一个位子上的元素将以链表的形式存放，新加入的放在链头，先前加入的在链尾
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
if (count >= threshold) {//检查是否需要进行扩容
// Rehash the table if the threshold is exceeded
rehash();
//扩容之后重新计算index
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) tab[index];//获取table数组在index的元素，如果非空，则新节点放在这个结点的前面，成为新的链表头
tab[index] = new Entry<>(hash, key, value, e);
count++;
}6.扩容rehash
思想：扩容长度=原长度*2+1，然后新建一个newCapacity数组，将原来的table数组元素拷贝到新的数组中去
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// overflow-conscious code
int newCapacity = (oldCapacity << 1) + 1;
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;
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;
}
}
}7.get
思想：首先获取key的hashCode，根据hashCode得到存储位置index，最后在table[index]取出元素即可，注意，这里可能存储了多个元素构成了一个链表，因此要进行一个key和hash的判断
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
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;
}二，HashMap
1.继承AbstractMap类，实现Map、Cloneable、Serializable接口（Hashtable继承的是Dicitionary类）
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable2.初始容量为16，最大容量为2的30次方，负载因子是0.75f
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;3.底层实现，数组+链表，Node[]就是哈希桶数组，实现了Map.Entry接口，本质就是一个映射，其长度length必须是2的n次方
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}4.构造函数
产生HashMap对象，其它的构造函数都是调用此构造函数来实现
initialCapacity：分配数组的大小，默认为16，且只能是2的幂次方
loadFactor：加载因子，当数组中存储的数据大于分配空间的总长度*loadFactor之后就进行扩容
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}5.hash方法，该哈希算法也就解释了为什么初始容量为16，并且每次自动扩展或是手动初始化时，长度必须是2的幂（服务于key到index的hash算法）
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}6.put方法，其中i = (n - 1) & hash，n为数组长度，so，HashMap的容量必须为2的幂次方
思想：
（1）判断键值对数组table[]是否为空或者null，否则resize进行扩容
（2）根据键值key计算hash值得到插入的数组索引i，如果table[i]=null，直接新建节点添加，转向（6），如果table[i]不为空，转向（3）
（3）判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则（4），相同指hashCode和equals
（4）判断table[i]是否为treeNode，如果是红黑树，则直接在树中插入键值对，否则（5）
（5）遍历table[i]，判断链表长度是否大于8，大于8的话把链表转为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作，遍历过程中若发现key已经存在，直接覆盖value即可
（6）插入成功后，判断实际存在的键值对数量size是否超过了最大容量threshold，如果超过则进行扩容
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)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) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}7.resize扩容
使用的是2次幂的扩展，即长度为原来的2倍，so，元素位置要么是在原位置，要么原位置移动2次幂的位置。因此，在扩充HashMap的时候，不需要像JDK1.7重新计算hash，只需要看原来的hash新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，该设计非常巧妙，既省去了重新计算hash时间，同时，由于新增的1bit是1还是0认为是随机的，一次resize的过程，均匀地把之前的冲突的结点分散到新的bucket了，这就是JDK1.8新增的优点
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {//如果table是有长度的，即不是第一次使用，则会进行扩容处理
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
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> 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<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> 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;
}
8.get
思想：首先根据key得到hashCode，然后根据hashCode得到该key在数组table的存储位置，接着在该位置寻找key值和hashCode值一致的结点，如果没有找到返回null
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}HashMap和Hashtable的几点区别
- 继承类不一样：HashMap继承AbstractMap，Hashtable继承的是Dictionary
- 初始容量不一样：HashMap默认为16，且智能是2的幂次方，Hashtable默认为11，容量并没有2的幂次方的限制，增加的方式是oldCap*2+1
- HashMap是线程不安全的，Hashtable通过synchronized是线程安全
- 使用的hashCode不一样：
- HashMap允许有一个key为null，多个value为null，而Hashtable不允许key和value为null
- 内部遍历方式不一样：HashMap和Hashtable都使用了Iterator，而由于历史原因，Hashtable还使用了Enumeration
三，ConcurrentHashMap
最近在看线程安全，云里雾里，从这个角度说一下吧，HashMap如何做到线程安全？一种可行的方法是使用操作集合的工具类Collections，即
Map map=Collections.synchronizedMap(new HashMap());生成一个名为SynchronizedMap的Map，它使用委托，将自己所有Map相关的功能交给传入的HashMap实现，而自己主要负责保证线程安全，具体源码看看，首先SynchronizedMap内包装了一个Map
private static class SynchronizedMap<K,V>
implements Map<K,V>, Serializable {
private static final long serialVersionUID = 1978198479659022715L;
private final Map<K,V> m; // Backing Map
final Object mutex; // Object on which to synchronize通过mutex实现对这个m的互斥操作，比如，get方法，以及其他相关的Map操作都会使用这个mutex进行同步保证线程安全
public V get(Object key) {
synchronized (mutex) {return m.get(key);}
}这个包装的Map可以满足线程安全的要求，但是，它在多线程环境中的性能表现并不好，无论是对Map的读取或者写入，都需要获得mutex的锁，这会导致所有对Map的操作全部进入等待状态，直到mutex锁可用，如果并发级别不高一般也就够用，但是，在高并发环境中，需要新的解决方法，即ConcurrentHashMap
思想：锁分段，首先将数据分成一段一段地存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问
比较复杂，具体的放在多线程并发里面吧！
参考：
https://blog.csdn.net/u010412719/article/details/51980632
https://blog.csdn.net/u014282557/article/details/77756560
https://blog.csdn.net/dou_yuan/article/details/77773530