Java集合之HashMap
本文将从以下几个方面来理解HashMap：
- 什么是哈希表
- HashMap源码分析
- HashMap和HashTable的区别
- 1.7和1.8有什么区别
哈希表
哈希表是种数据结构，它可以提供快速的插入操作和查找操作。第一次接触哈希表时。不论哈希表中有多少数据，插入和删除（有时包括侧除）只需要接近常量的时间即0(1）的时间级。
-
为什么哈希这么快呢
首先不得不提哈希函数了（ p= H(key) ），哈希函数就是给一个任意大小的数据生成出一个固定长度的数据，作为它的映射 ，这种容易产生哈希冲突的情况。
-
哈希函数的构造方法
- 数字分析法
- 平方取中法
- 分段叠加法
- 除留余数法
- 伪随机数法
-
处理冲突的方法
-
开放地址法
当关键字key的哈希地址p=H（key）出现冲突时，以p为基础，产生另一个哈希地址p1，如果p1仍然冲突，再以p为基础，产生另一个哈希地址p2，…，直到找出一个不冲突的哈希地址pi ，将相应元素存入其中
-
拉链法
这种方法的基本思想是将所有哈希地址为i的元素构成一个称为同义词链的单链表，并将单链表的头指针存在哈希表的第i个单元中，因而查找、插入和删除主要在同义词链中进行。链地址法适用于经常进行插入和删除的情况
HashMap源码分析
JDK1.7
图表
- 实现了Serializable接口，可以序列化、反序列化
- 实现了Cloneable接口，可以克隆
属性
/**
* 默认初始容量16，必须为2的幂次方
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大的容量值，用于通过构造器指定更大的值时所给定的值
* 也就是容量值必须小于等于1 << 30（2的30次幂）
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认的负载因子.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* table是HashMap中存值的数组，它的长度是按需变化的，它的长度 *（length）通常是2的幂指数个.
*/
transient Entry<K,V>[] table;
/**
*Map中存放键值对的个数
*/
transient int size;
/**
* 加载阈值，下一次调整Map长度的临界值 (capacity * load factor).
* @serial
*/
int threshold;
/**
* HashMap的加载因子，在构造器中指定的.
* @serial
*/
final float loadFactor;
/**
* HashMap对象被结构性修改的次数， 譬如：put、remove，
* rehash操作 。这个属性主要用于多线程并发时发生的fail-fast。
*/
transient int modCount;
/**
* 应用在字符串键的备选哈希函数的容量阈值，这个备选哈希函数可
*以减少由于弱哈希值引起碰撞的概率。
*默认值是Integer.MAX_VALUE
*它可能被系统配置的属性值{@code jdk.map.althashing.threshold}
*覆盖。如果改属性值是1，备选哈希函数将被使用，如果是-1，备选
*哈希函数将永远不会被使用。
*/
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
多参构造方法
/**
* 通过指定的容量和负载系数构建一个空的HashMap
*
* @param initialCapacity 指定容量
* @param loadFactor 负载系数
* @throws IllegalArgumentException 如果这个容量为负或者负载因子非正的就抛此异常
*/
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)//如果容量<0则抛出异常
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)//如果初始容量超过最大1<<32
initialCapacity = MAXIMUM_CAPACITY;//则使用最大容量
if (loadFactor <= 0 || Float.isNaN(loadFactor))//如果负载因子<0或者不是数字
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;//计算出下一次调节Map长度的临界值
init();
}
通过Map构造
/**
* 根据传入的指定的Map参数去初始化一个新的HashMap，该HashMap拥有着和原Map中相同的映射关系
* 以及默认的负载因子（0.75f）和一个大小充足的初始容量
*
* @param m 一个映射关系将会被新的HashMap所取代的Map
* @throws 如果这个Map为空的话，将会抛出空指针异常
*/
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
inflateTable(threshold);初始化HashMap
putAllForCreate(m);//这就是将指定Map转换为HashMap的方法
}
要想看懂这个构造方法，得先看懂inflateTable和putAllForCreate两个方法；
private void inflateTable(int toSize) {
// Find a power of 2 >= toSize
//计算出大于toSize最临近的2的N此方的值
//假设此处传入6, 那么最临近的值为2的3次方，也就是8
int capacity = roundUpToPowerOf2(toSize);
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];//初始化数组
initHashSeedAsNeeded(capacity);//初始化hash码
}
private void putAllForCreate(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putForCreate(e.getKey(), e.getValue());
}
private void putForCreate(K key, V value) {
int hash = null == key ? 0 : hash(key);//通过位运算计算出hash值
int i = indexFor(hash, table.length);//通过取模的方法返回传入的hash在table中的索引值
//由于table[i]处可能不止有一个元素（多个会形成一个链表），因此，此处写这样一个循环
//当key存在的时候，直接将key的值设置为新值
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
//当key不存在的时候，就在table的指定位置新创建一个Entry
createEntry(hash, key, value, i);
}
//在table的指定位置新创建一个Entry
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
put()方法
/**
* 将指定的key和value进行关联，如果已经存在则value被替换
*
* @param key 与指定value关联的key
* @param value 与指定key关联的value
* @return 这个key关联的之前的value
*
*/
public V put(K key, V value) {
//table为空，就先初始化
if (table == EMPTY_TABLE) {
inflateTable(threshold);//初始化数组,创建保存的数组
}
//为null的情况， 只允许有一个为null的key
if (key == null)
return putForNullKey(value);
//计算hash值
int hash = hash(key);
//根绝hash找到指定的位置
int i = indexFor(hash, table.length);
//table中，同一个位置（也就是同一个hash）可能出现多个元素（链表实现），故此处需要循环
//如果key已经存在，那么直接设置新值
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//修改次数+1，在多线程的情况，如果在遍历取值时，expectModCount!=modCount则报错ConcurrentModificationException
modCount++;
//key不存在，则新增一个entry
addEntry(hash, key, value, i);
return null;
}
//将具有指定键、值和哈希代码的新项添加到指定的桶
void addEntry(int hash, K key, V value, int bucketIndex) {
//当长度到了临界值或者长度不够的时候，就该扩容了
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);//扩容方法
hash = (null != key) ? hash(key) : 0;//计算出hash值
bucketIndex = indexFor(hash, table.length);//找出table中指定hash的值
}
createEntry(hash, key, value, bucketIndex);
}
扩容机制
//扩容方法
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;//保存扩容前的长度
if (oldCapacity == MAXIMUM_CAPACITY) {//扩容前的数组大小如果已经达到最大(2^30)了
threshold = Integer.MAX_VALUE;//就将临界点设置为2^31-1这样下次就不再扩容了，让hash碰撞
return;
}
Entry[] newTable = new Entry[newCapacity];//传入的newCapacity是前长度的两倍
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//扩容之后，重新计算hash，然后再重新根据hash分配位置
//由此可见，为了保证效率，如果能指定合适的HashMap的容量，会更合适
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
//如果hashseed有变化则需要重新计算key的hash值
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
//这里采用的是头插法，多线程的情况下这个地方容易发生死循环。
//为什么会死循环呢。当线程A,B同时进行扩容
e.next = newTable[i];
//当线程A执行到此，cpu时间片到期，则该线程需要挂起。
//CPU开始执行线程B，并在线程B中成功的完成了数据迁移。
//此时主内存中newTable和table都是最新的。随后线程A获得CPU时间片继续执行
//容易造成一种e.next=null. next=null的情况。就会产生一个闭环
newTable[i] = e;
e = next;
}
}
}
get()方法
// 获取key对应的value
public V get(Object key) {
if (key == null)
//如果key为null,调用getForNullKey()
return getForNullKey();
//key不为null,调用getEntry(key);
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
//当key为null时,获取value
private V getForNullKey() {
if (size == 0) {
return null;//链表为空,返回null
}
//链表不为空,将“key为null”的元素存储在table[0]位置，但不一定是该链表的第一个位置！
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
//key不为null,获取value
final Entry<K,V> getEntry(Object key) {
if (size == 0) {//判断链表中是否有值
//链表中没值,也就是没有value
return null;
}
//链表中有值,获取key的hash值
int hash = (key == null) ? 0 : hash(key);
// 在“该hash值对应的链表”上查找“键值等于key”的元素
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
//判断key是否相同
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;//key相等,返回相应的value
}
return null;//链表中没有相应的key
}
首先，如果key为null，则直接从哈希表的第一个位置table[0]对应的链表上查找。记住，key为null的键值对永远都放在以table[0]为头结点的链表中，当然不一定是存放在头结点table[0]中。
如果key不为null，则先求的key的hash值，根据hash值找到在table中的索引，在该索引对应的单链表中查找是否有键值对的key与目标key相等，有就返回对应的value，没有则返回null。转载至 https://blog.csdn.net/bushanyantanzhe/article/details/79182880
remove()方法
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
//通过key去移除entry
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {//链表为空则返回null
return null;
}
int hash = (key == null) ? 0 : hash(key);//计算出hash值
int i = indexFor(hash, table.length);//通过hash值找到索引
Entry<K,V> prev = table[i];//找到索引所在那一行的链表。这指的是链表的首节点
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
//如果要删除的节点是首节点，则将链表中的下一个节点设置为首节点
if (prev == e)
table[i] = next;
else
//如果首节点不是要删除的节点，将首节点prev的next存e的next节点
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
JDK1.8
介绍1.8在1.7基础上改动很大的几个点：
put()方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//主要put的方法
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;//下面会介绍resize方法
if ((p = tab[i = (n - 1) & hash]) == null)//判断hash值在数组中是否存在
tab[i] = newNode(hash, key, value, null);//不存在则直接创建
else {//存在则走这边，也就是hash冲突了
Node<K,V> e; K k;//创建一个链表
//如果hash值相等，key也相等，或者equals相等，赋值给e
if (p.hash == hash &&//判断通过hash取到的tab[].hash==需要put的hash
((k = p.key) == key || (key != null && key.equals(k))))//并判断key是否相同
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) {
//new一个新的Node对象并把当前Node的next引用指向该对象
//也就是说原来该位置上只有一个元素对象，现在转成了单向链表
p.next = newNode(hash, key, value, null);
//也就是当链表长度>=8时（TREEIFY_THRESHOLD==8）
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;
}
}
//用新的value替换旧的value并返回旧的value
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)//容量是否大于临界点，第一次put的时候threshold为12
resize();//扩容
//官方注释：回调以允许LinkedHashMap
afterNodeInsertion(evict);//子类实现
return null;
}
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//引入扩容前的数组，当然第一次进来的时候oldTab也是为null的
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {//说明不是第一次进行put
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 扩容为之前的两倍double
}
//构造的时候指定了initialCapacity则走这里
//则table大小为threshold, 即大于指定initialCapacity的最小的2的整数次幂
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { //如果构造函数没有指定initialCapacity, 则table大小为16
newCap = DEFAULT_INITIAL_CAPACITY;//容量初始化默认的16
//初始化下次扩容的大小为默认负载因子*默认大小（0.75f*16）
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
//两个链表, 我们把它称为 lo链表 和 hi链表,
//loHead 和 loTail 分别指向 lo链表的头节点和尾节点,
//首先准备了两个链表 lo 和 hi, 然后我们顺序遍历该存储桶上的链表的每个节点, 如 //果 (e.hash & oldCap) == 0, 我们就将节点放入lo链表, 否则, 放入hi链表.
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 插入lo链表
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 插入hi链表
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//lo链表非空, 我们就把整个lo链表放到新table的j位置上
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//hi链表非空, 我们就把整个hi链表放到新table的j+oldCap位置上
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
参考了该篇博客： https://segmentfault.com/a/1190000015812438?utm_source=tag-newest ，特别感谢！
为什么在JDK1.7的时候是先进行扩容后进行插入，而在JDK1.8的时候则是先插入后进行扩容的 呢？
get()方法
public V get(Object key) {
Node<K,V> e;
//计算出hash值并传入getNode方法
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//get的主要实现
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) {//table不为空
if (first.hash == hash && // 每次在第一个节点hash值和key值是否相同，因为hash碰撞的几率很小所以总是找第一个节点，提高效率
((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;
}
总结
1、计算key的hash值，算出元素在底层数组中的下标位置。
2、通过下标位置定位到底层数组里的元素（也有可能是链表也有可能是树）。
3、取到元素，判断放入元素的key是否==或equals当前位置的key，成立则替换value值，返回旧值。
4、如果是树，循环树中的节点，判断放入元素的key是否==或equals节点的key，成立则替换树里的value，并返回旧值，不成立就添加到树里。
5、否则就顺着元素的链表结构循环节点，判断放入元素的key是否==或equals节点的key，成立则替换链表里value，并返回旧值，找不到就添加到链表的最后。
HashMap和HashTable的区别
通过图表来查看
-
HashTable
-
HashMap
总的来说两者区别有：
-
由上能看出HashTable是继承了Dictionary类，而HashMap则是集成了AbstractMap；
-
Hashtable中，key和value都不允许出现null值。但是如果在Hashtable中有类似put(null,null)的操作，编译同样可以通过，因为key和value都是Object类型，但运行时会抛出NullPointerException异常，这是JDK的规范规定的。
HashMap中，null可以作为键，这样的键只有一个； -
HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。
Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。
-
Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。
HashMap1.7和1.8有什么区别
- 底层数据结构不一样，1.7是数组+链表，1.8则是数组+链表+红黑树结构（当链表长度大于8，转为红黑树）。
- JDK1.8中resize()方法在表为空时，创建表；在表不为空时，扩容；而JDK1.7中resize()方法负责扩容，inflateTable()负责创建表。
- 当1.8中的桶中元素处于链表的情况，遍历的同时最后如果没有匹配的，直接将节点添加到链表尾部；而1.7在遍历的同时没有添加数据，而是另外调用了addEntry()方法，将节点添加到链表头部。
- 在扩容的时候：1.7在插入数据之前扩容，而1.8插入数据成功之后扩容。
- 等…
239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
