一、HashMap的成员变量
int DEFAULT_INITIAL_CAPACITY = 16：默认的初始容量为16
int MAXIMUM_CAPACITY = 1 << 30：最大的容量为 2 ^ 30
float DEFAULT_LOAD_FACTOR = 0.75f：默认的加载因子为 0.75f
Entry< K,V>[] table：Entry类型的数组，HashMap用这个来维护内部的数据结构，它的长度由容量决定
int size：HashMap的大小
int threshold：HashMap的极限容量，扩容临界点（容量和加载因子的乘积）
加载因子
1. 加载因子是哈希表在元素增加之前可以达到多满的一种尺度，相当于一个阈值。当元素的个数达到阈值时，就会进行扩容。它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。
2. 对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，加载因子是表示Hsah表中元素的填满的程度.若加载因子越大,填满的元素越多,好处是,空间利用率高了,但冲突的机会加大了.反之,加载因子越小,填满的元素越少,好处是冲突的机会减小了,但空间浪费多了.冲突的机会越大,则查找的成本越高.反之,查找的成本越小
3. 因而,查找时间就越小,因此,必须在”冲突的机会”与”空间利用率”之间寻找一种平衡与折衷. 这种平衡与折衷本质上是数据结构中有名的”时-空”矛盾的平衡与折衷.
4.系统默认负载因子为0.75，一般情况下我们是无需修改的。
5.当哈希表中的数量超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
二、HashMap的数据结构
我们知道在Java中最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap也是如此。实际上HashMap是一个“链表散列”，如下是它数据结构：
从上图我们可以看出HashMap底层实现还是数组，只是数组的每一项都是一条链。其中参数initialCapacity就代表了该数组的长度。下面为HashMap构造函数的源码：
//无参构造器
public HashMap() {
//默认初始容量大小为16,默认的加载因子为0.75f
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
} public HashMap(int initialCapacity, float loadFactor) {
//初始容量不能小于0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//初始容量不能超过1073741824
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//加载因子不能小于等于0,或者加载因子不能是非数字
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//设置加载因子
this.loadFactor = loadFactor;
//设置临界值
threshold = initialCapacity;
//伪构造,里面没有代码
init();
}put()方法代码
public V put(K key, V value) {
//先判断哈希表是否为空,第一次put的话肯定是为空的，
if (table == EMPTY_TABLE) {
// roundUpToPowerOf2方法的作用是将构造器传入的容量初始化大小
//转成最接近2的n字方值,为什么要2的n字方,下面会提到
int capacity = roundUpToPowerOf2(threshold);
//临界值是加载因子*容量大小
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//创建一个Entry数组
table = new Entry[capacity];
//initHashSeedAsNeeded方法的作用:找到与该实例的一个哈希掩码值,使哈希碰撞几率更为小.里
//面会生成一个hashSeed，将会在生成哈希值里面可能会用到。
initHashSeedAsNeeded(capacity);
}
//如果key为null
if (key == null)
//这个方法下面讲解
return putForNullKey(value);
//计算key的哈希值
int hash = hash(key);
//计算改哈希值在哈希表的下标
int i = indexFor(hash, table.length);
//如果刚刚计算出来的下标在哈希表里面为空的话，将不会进入循环
//不为空将遍历table[i]的链表
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//判断该链表上是否有相同的哈希值和相同的地址值,或者key相同
//若存在则覆盖旧值,返回旧值
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//这个方法下面讲解
addEntry(hash, key, value, i);
return null;
}1.为什么容量大小要为2的n次方，请点击
2. 如果为null，则调用putForNullKey：这就是为什么HashMap可以用null作为键的原因，来看看HashMap是如何处理null键的：
private V putForNullKey(V value) {
//查找哈希表中0索引的位置，是否不为空，如果不为空，则遍历0索引的链表
//查找key==null的键值，覆盖并返回旧值。
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//将null的键放入哈希表0索引的位置
addEntry(0, null, value, 0);
return null;
}3.添加新结点的方法
void addEntry(int hash, K key, V value, int bucketIndex) {
//如果结点个数大于或等于临界值和该哈希表指定的索引位置不为null
if ((size >= threshold) && (null != table[bucketIndex])) {
//扩容会在重点讲解
resize(2 * table.length);
//这一步就是对null的处理，如果key为null，hash值为0，
//也就是会插入到哈希表的表头table[0]的位置
hash = (null != key) ? hash(key) : 0;
//因为扩容了，需要重新计算哈希表的位置
bucketIndex = indexFor(hash, table.length);
}
//创建Entry结点的操作
createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
//查找出指定索引的结点对象，目的：形成一个链表
Entry<K,V> e = table[bucketIndex];
//第一个参数书哈希值，第二个是key值，第三个是value值
//第四个哈希表指定索引结点的对象，这样就形成了一个单链链表了。
//为什么要放在链表头，因为好像作者说后面放进去的结点会更大几率使用到。欢迎纠错。
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}5.扩容
void resize(int newCapacity) {
//引用扩容前的Entry数组
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//如果扩容前的数组大小如果已经达到最大(2^30)了
//修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//创建一个新的哈希表
Entry[] newTable = new Entry[newCapacity];
//将当前所有的哈希表数据复制到新的哈希表
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
//计算临界值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//将当前所有的哈希表数据复制到新的哈希表
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;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//因为哈希表的长度变了，需要重新计算索引
int i = indexFor(e.hash, newCapacity);
//第一次循环的newTable[i]为空，赋值给当前结点的下一个元素，
//下面有图会讲解这句代码的含义
e.next = newTable[i];
//将结点赋值到新的哈希表
newTable[i] = e;
e = next;
}
}
}
get方法
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
//key为null的处理方法
private V getForNullKey() {
if (size == 0) {
return null;
}
//因为key为null添加的时候是放在哈希表索引0的位置的。
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
//找到key为null，则终止循环，返回值
if (e.key == null)
return e.value;
}
return null;
}
//获取值
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
//计算key的哈希值
int hash = (key == null) ? 0 : hash(key);
//table[indexFor(hash, table.length）这个方法的目的是找到对应的链表，开始遍历
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}remove方法
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
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 = next;
e.recordRemoval(this);
return e;
}
//如果走到这一步，则说明该元素在单向链表上
prev = e;
e = next;
}
return e;
}迭代器
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next; // next entry to return
int expectedModCount; // For fast-fail
int index; // 记录索引
Entry<K,V> current; // current entry
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
//找到在数组里第一个元素
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
final Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
//如果在这个索引上没有单向链表的话，
if ((next = e.next) == null) {
Entry[] t = table;
//向下个索引查找不为null的元素
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k);
expectedModCount = modCount;
}
}参考文章
https://blog.csdn.net/jeffleo/article/details/54946424
https://blog.csdn.net/qq_27093465/article/details/52270519