本文以JDK1.8源码为例。
一、HashMap底层结构
HashMap底层采用数组+单向链表+红黑树实现，结构示意图如下：
HashMap其实就是一个数组，源码如下定义：
transient Node<K,V>[] table;
table就对应图中黄色虚线围起来的16个小正方形（16表示容量，后面会说明）。数组的每个元素存储的是null，或者Node<K,V>类型数据，或者TreeNode<K,V>类型数据。TreeNode<K,V>是Node<K,V>的子类。16个小正方形分为三类，第一类是虚线小正方形，存储的是null，也就是还没有元素放入其中。蓝色实心小正方形存储的数据类型是单个Node<K,V>，如果是单项链表，也只存储链表的第一个元素，黑色实心小正方形存储的数据类型是TreeNode<K,V>，它是一个红黑二叉树，保存红黑二叉树的根节点元素。先解释下Node<K,V>和TreeNode<K,V>类型。它们都是类。Node<K,V>中保存了四个重要的值，分别是：
final int hash;
final K key;
V value;
Node<K,V> next;
hash是key的哈希值，如下计算：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
如果key是null值，key的哈希值就是0，否则调用key的hashcode方法求出h，然后与h右移16位后求异或运算，结果作为key的哈希值，所以这里key的哈希值和key的hashcode实现有关。Node<K,V>中还有next变量，它指向下一个Node<K,V>类型，有了next后，数组table只需要存储链表的第一个元素，链表的其他元素可以通过next进行遍历访问。key和value就不用解释了，它才是我们真正要储存的数据，其他数据结构（比如单向链表和红黑二叉树）都是为了快速存储和查询key和value而设计的。下面再看下TreeNode<K,V>类型，它保存了如下5个重要的值：
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
这些值也是为了访问方便而设计的。parent可以访问当前节点的父节点，left可以访问当前节点的左节点，right可以访问当前节点的又节点。注意TreeNode是Node的子类，所以Node的hash，key和value也会被继承下来，也就是说TreeNode也有这三个值。
源码中提供了四个构造方法来初始化HashMap：
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);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
不论是哪个方法，都涉及到三个变量：容量（initialCapacity），阈值（threshold）和加载因子（loadFactor ）
（1）容量
//默认初始容量是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大初始容量
static final int MAXIMUM_CAPACITY = 1 << 30;
在初始化HashMap时，可以指定初始容量，如果不指定则使用默认初始容量16。比如：
Map<Integer,String> map = new HashMap<>();
如果指定的初始容量小于0，则抛出异常，如果超过1 << 30（也就是2^30），则初始容量就是最大值1 << 30。如果指定初始容量为cap，则会调用tableSizeFor方法，找到一个大于等于cap的最小的2幂次方，赋值给threshold用于扩容。比如
Map<Integer,String> map = new HashMap<>(10);
因为大于等于10的最小的2的幂次方是16，所以threshold=16，注意这里只是暂时赋值给threshold，后面会看到代码中又将threshold赋值给了容量。tableSizeFor代码如下：
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}其实new HashMap<>(10);只是初始化了一些变量，并没有创建table。
（2）加载因子
//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//加载因子
final float loadFactor;
初始化时如果没有指定加载因子使用默认值0.75，如果指定的加载因子小于等于0或者不是数值，抛出异常。
容量（initialCapacity），阈值（threshold）和加载因子（loadFactor ）的关系如下：
threshold=initialCapacity*loadFactor;
刚才我们已经说明new HashMap<>(10)，并没有真正创建table，那么它是什么时候创建的呢？容量（initialCapacity），阈值（threshold）和加载因子（loadFactor ）又是如何赋值的呢？现在向map中添加一个键值对(1,"hello")，如下：
Map<Integer,String> map = new HashMap<>(10);
map.put(1,"hello");
第一行代码执行完，threshold=16，然后调用put方法，源码如下：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}put方法调用了putVal方法（注意hash(key)），源码如下：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果数组为空或者没有元素，调用resize方法扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
.......
此处省略了部分代码
.......
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}因为table==null，满足if条件，所以会调用resize方法，源码如下：
final Node<K,V>[] resize() {
//===步骤1===
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
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
}
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;
........
此处省略部分代码
........
return newTab;
}核心代码如下：
threshold = newThr;
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
这里threshold被重新赋值为16*0.75=12，并真正创建一个可以容纳16个元素的table数组。table完成初始化后，第一个键值对放在哪个位置呢？源码采用计算哈希值的方式寻找table下标，如下：
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);上面n现在是16，hash等于1的hash值，(n - 1) & hash求与运算后，获取到下标i，如果tab[i]没有元素，就创建一个Node<K,V>，将数据放入这个位置，因为是第一次put，当然没有元素。所以可以很顺利放入。如果继续向map中put元素，HashMap又将如何处理呢？如下：
Map<Integer,String> map = new HashMap<>(10);
map.put(1,"hello");
map.put(2,"word");
现在table有16个位置，已经有一个位置填入了(1,"hello")，调用map.put(2,"word");时，依然使用
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);寻找下标，如果寻找的位置没有元素，直接存储进去，这里(1,"hello")和(2,"word")通过哈希寻找的位置一般不会相同，所以可以正常放入。如果(key,value)和(1,"hello")通过哈希寻找的位置相同，如何存放呢？需要考虑两种情况：
（1）equals方法不相等
equals方法不相等是指，一个key为null，另一个key不为null，显然两个不相等。当两个key都不为null时，key.equals(1)返回false，认为两个不相等。这和key的equals方法实现有关。这时(key,value)和(1,"hello")会以链表的形式存储，其中(1,"hello")的next指向(key,value)
（2）equals方法调用相等
也就是两个key都为null，或者key.equals(1)返回true。此时会使用(key,value)的value替换(1,"hello")中的"hello")，但是1不会被key替换，可能key和1本身不相同，比如key是100.所以equals的实现很重要。
到这里我们需要明白两点，hashmap首先通过计算key的hash，寻找要插入到table中的位置，如果位置上没有元素，直接插入，如果有元素，而且只有一个元素，再判断这个元素的key和要插入的key是否equals，如果相等替换value，如果不相等放入该元素的后面。
随着元素的不断put，会出现如下情况：
（1）table中空位置越来越少
什么时候扩容呢？上面的这个例子容量是16，而阈值是12，当table中的元素个数超过12，也就是空白位置不足4个，就会扩容，容量扩大为原来的双倍，也就是32，所以我们看到阈值时扩容的一个界限，当table元素个数超过这个阈值，就会自动双倍扩容。
（2）链表越来越长
还有一种情况是，每次put进去的key，寻找的插入位置都是一样，这样链表会越来越长，当链表中的元素个数达到8个，下一个元素插入进来，而且这个元素的key和8个元素的key不相等，它会暂时插入到链表的末尾，因为每个元素都是Node类型，紧接着，HashMap会将每个元素类型转换为TreeNode，并将单向链表变成双向链表（主要通过TreeNode的prev指向前一个元素），
然后HashMap再将这个双向链表变成红黑二叉树，规则如下，HashMap会遍历这个双向链表，第一个元素作为红黑二叉树的根节点，然后比较第二个元素的key的hash和根节点key的hash，如果比根节点的hash值要小或者相等，放在根节点的左边(left),如果比根节点的hash值要大，放在根节点的右边，依次这样遍历。这里会出现一种情况，如果原来的双向链表的每个元素的key的hash本来就是依次增大，按照这种规则逻辑，形成的二叉树和原来的链表是一样的，好在红黑二叉树，是一种平衡树，它将双向链表中的元素逐个放入红黑二叉树时，会采用平衡策略。可以参考红黑二叉树的知识。最后不会出现二叉树很长。这也是为了查询更快、
二、HashMap和HashTable区别
官方文档原文如下：
* Hash table based implementation of the <tt>Map</tt> interface. This
* implementation provides all of the optional map operations, and permits
* <tt>null</tt> values and the <tt>null</tt> key. (The <tt>HashMap</tt>
* class is roughly equivalent to <tt>Hashtable</tt>, except that it is
* unsynchronized and permits nulls.) This class makes no guarantees as to
* the order of the map; in particular, it does not guarantee that the order
* will remain constant over time.HashMap和HashTable基本等价，有两点不同：
（1）permits nulls
HashMap允许键值对是空值的情况，而HashTable不可以。前面已经提到。测试如下：
package com.leboop;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
public class HashMapTest {
public static void main(String[] args) {
//初始化map和table
Map<Integer,String> map = new HashMap<>();
Map<Integer,String> table = new Hashtable<>();
//向map添加key=null,value=null，正常运行
map.put(null, null);
//正常输出1
System.out.println(map.size());
//向table中添加key=null，捕获到空指针异常
try{
table.put(null, "hello");
}catch(NullPointerException e){
//输出:key空指针异常：java.lang.NullPointerException
System.out.println("key空指针异常："+e);
}
map.put(1,null);
map.put(2,null);
/**
* 输出：
* null=null
* 1=null
* 2=null
*/
for(Entry<Integer, String> e:map.entrySet()){
System.out.println(e.getKey()+"="+e.getValue());
}
try{
table.put(1, null);
}catch(NullPointerException e){
//value空指针异常：java.lang.NullPointerException
System.out.println("value空指针异常："+e);
}
}
}
（2）unsynchronized
HashMap不能异步，也就是说线程不安全，而HashTable是线程安全的，HashTable的部分源码如下：
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;
}
}
addEntry(hash, key, value, index);
return null;
}public synchronized V remove(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>)tab[index];
for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
modCount++;
if (prev != null) {
prev.next = e.next;
} else {
tab[index] = e.next;
}
count--;
V oldValue = e.value;
e.value = null;
return oldValue;
}
}
return null;
}HashTable中的方法基本都有关键字synchronized。但是HashMap中并没有synchronized，我们先看一段测试代码：
package com.leboop;
import java.util.HashMap;
import java.util.Map;
public class Difference {
private static Map<String, String> map=new HashMap<>();
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
Thread t = new Thread("线程" + i){
public void run() {
double i = Math.random() * 100000;
map.put("键" + i, "值" + i);
map.remove("键" + i);
System.out.println(Thread.currentThread().getName() + " size = " + map.size());
}
};
t.start();
}
}
}
输出结果：
线程24 size = 0
线程23 size = 0
线程11 size = 0
线程12 size = 2
线程0 size = 1
线程20 size = 0
线程26 size = 0
线程3 size = 1
线程15 size = 1
线程1 size = 1
线程17 size = 1
线程6 size = 0
线程21 size = 0
线程22 size = 0
线程27 size = 0
线程25 size = 0
线程4 size = 1
线程29 size = 0
线程10 size = 1
线程8 size = 1
线程9 size = 2
线程2 size = 1
线程5 size = 1
线程32 size = 0
线程7 size = 2
线程43 size = 0
线程35 size = 2
线程41 size = 0
线程18 size = 2
线程19 size = 4
线程16 size = 0
线程37 size = 0
线程14 size = 1
线程13 size = 2
线程30 size = 0
线程36 size = 0
线程42 size = 0
线程40 size = 0
线程39 size = 0
线程31 size = 1
线程28 size = 0
线程53 size = 1
线程44 size = 0
线程46 size = 0
线程52 size = 0
线程50 size = 0
线程51 size = 0
线程49 size = 0
线程45 size = 0
线程47 size = 0
线程34 size = 0
线程48 size = 0
线程33 size = -1
线程38 size = -1
线程54 size = -1
线程56 size = -1
线程59 size = -1
线程57 size = -1
线程58 size = -1
线程60 size = -1
线程63 size = -1
线程55 size = -1
线程64 size = -1
线程62 size = -1
线程61 size = -1
线程65 size = -1
线程66 size = -1
线程67 size = -1
线程68 size = -1
线程69 size = -1
线程70 size = -1
线程71 size = -1
线程72 size = -1
线程73 size = -1
线程74 size = -1
线程75 size = -1
线程76 size = -1
线程77 size = -1
线程78 size = -1
线程79 size = -1
线程80 size = -1
线程81 size = -1
线程82 size = -1
线程84 size = -1
线程83 size = -1
线程85 size = -1
线程86 size = -1
线程87 size = -1
线程88 size = -1
线程89 size = -1
线程90 size = 0
线程91 size = -1
线程92 size = -1
线程93 size = -1
线程94 size = -1
线程95 size = -1
线程96 size = -1
线程97 size = -1
线程98 size = -1
线程99 size = -1
从输出结果size=-1中显而易见。线程操作数据的时候是从主存拷贝一个变量副本进行操作，这里不再累述。
（3）默认初始容量
HashMap默认容量16，HashTable默认容量11
三、ConcurrentHashMap简介
If a
* thread-safe implementation is not needed, it is recommended to use
* {@link HashMap} in place of {@code Hashtable}. If a thread-safe
* highly-concurrent implementation is desired, then it is recommended
* to use {@link java.util.concurrent.ConcurrentHashMap} in place of
* {@code Hashtable}.HashTable非常粗暴，使用synchronized关键字，多线程环境下效率很低。我们在HashTable类注释上看到上面一段说明：如果不要求线程安全，推荐使用HashMap，如果要求线程安全，推荐使用ConcurrentHashMap。该类不支持put键值对中含null值，通过volatile关键字，CAS锁支持多线程安全。比synchronized关键字效率高（线程上下文切换耗时）。
327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
