一、继承关系
public class HashMap<K,V>
extends AbstractMap<K,V>//继承自AbstractMap父类
implements Map<K,V>, Cloneable, Serializable//实现Map接口、克隆、序列化
二、属性及默认值
默认容量（哈希结构中数组默认大小）为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量为2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
//加载因子，当有效个数为16*0.75=12时进行扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//默认存储值
static final Entry<?,?>[] EMPTY_TABLE = {};
//HashMap存储结构，Entry类型的数组
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//Entry节点的有效个数
transient int size;
//扩容的阈值，控制扩容
int threshold;
final float loadFactor;
//修改次数即版本号
transient int modCount;
//Entry存储键值对，HashMap底层存储结构为哈希表
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
//用来解决哈希冲突，在同一hash索引下的值通过next连接
Entry<K,V> next;
int hash;
}
解决哈希冲突的方法：链地址法即产生哈希冲突的节点用链表连接
HashMap中存储的数据在table属性上
JDK1.7中HashMap存储结构是哈希表
哈希结构：通过键（key）找到值（value）的结构，底层数组，对数据的访问通过哈希函数（键和值的映射关系）
哈希冲突：根据key通过哈希函数计算出在数组中的位置相同
两种生成哈希函数方式：
①直接寻址法 f(x) = kx + b（k和b是常数）
②除留余数法 f(x) = x mod m（m是常数，m<=哈希长度）
两种哈希冲突的解决方式：①链地址法 ②线性探测法
三、构造方法
public HashMap(int initialCapacity, float loadFactor) {
//参数为初始大小和加载因子
if (initialCapacity < 0)
//给定初始大小小于0抛异常
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
//给定初始大小大于2^30则初始大小为2^30
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
//加载因子小于0或不是数字抛异常
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;
init();//这里没有实现该方法，与之前的jdk版本作兼容
}
public HashMap(int initialCapacity) {
//参数为初始大小，默认加载因子为0.75
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {//无参构造，默认容量大小为16，加载因子为0.75
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(Map<? extends K, ? extends V> m) {//参数为实现Map接口的集合
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
//两个集合容量大的作为默认大小
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);//默认加载因子为0.75
inflateTable(threshold);//初始化HashMap
putAllForCreate(m);//将Map转为HashMap
}
四、基本方法（CRUD）
1.增加
public V put(K key, V value) {
if (table == EMPTY_TABLE) {//第一次插入元素
//初始化HashMap，创建Entry数组，大小为大于2^n最邻近的值
inflateTable(threshold);
}
if (key == null)//key为空时存放在table[0]
return putForNullKey(value);
int hash = hash(key);//根据key计算hash值
//根据指定hash函数找出key所在下标，与table.length进行与运算
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//key存在的判等条件，两种key的判等是区分基本数据类型和引用数据类型
if (e.hash == hash && ((k = e.key) == key ||
key.equals(k))) {//若key存在，则将value值进行覆盖
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);//若key不存在，将节点放到table中
return null;
}
private void inflateTable(int toSize) {
//将初始容量定为大于等于当前初始值最近的2的次方值
//此时涉及的都是位运算，效率更高
int capacity = roundUpToPowerOf2(toSize);
threshold = (int) Math.min(capacity * loadFactor,
MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {//已经存在key为null的节点，覆盖value值
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
//若table容量不够
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);//2倍扩容并重新哈希
hash = (null != key) ? hash(key) : 0;//重新计算扩容后的hash值
//重新找出此hash值在table中的下标
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
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++;
}
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
//将String类型的每一个字符转换为ASCII码（int类型）
return sun.misc.Hashing.stringHash32((String) k);
}
//哈希码：同一个类的对象按照自己不同的特征尽量的有不同的哈希码，但不表示不同的对象哈希码完全不同
h ^= k.hashCode();//异或，相同为0，不同为1
//使数据分布更加均匀，减少哈希冲突次数
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
static int indexFor(int h, int length) {
return h & (length-1);//位与，只截取哈希值的后几位
}
①若数组为空时，则初始化数组table，大小为大于2^n最邻近的值。
②判断key是否为null。若为null，存储在哈希表的0号索引，若key重复，将原来的value值进行覆盖。若不为null，在table[0]的位置新增一个key为null，value为传进来的值的节点
③通过key的hashCode进行一系列异或操作计算出hash值，若key为String类型则通过ASCII码将hashCode转为int类型。通过hash值与数组长度进行位与运算计算出key所在位置的索引。
④遍历key所在索引的链表，若key已经存在即e.hash == hash && (e.key == key || key.equals(k))，用新的value值覆盖原来的value值，返回原来的value值。
⑤若key不存在，调用addEntry方法。若size大于等于阈值则需要进行2倍扩容，若原来数组长度已经达到最大容量，则不用扩容。之后重新哈希（transfer方法，说明HashMap是线程不安全的），阈值为新的容量乘以加载因子。扩容之后根据key重新计算hash值以及索引值，再利用头插法将节点插入table中。
2.删除
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
//key为null和不为null同一进行处理（put方法优化思路）
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;
//与之前key判等条件不同，key可能为null
if (e.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;
}
3.查找
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
private V getForNullKey() {
if (size == 0) {//可以不加，加了提高效率
return 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;
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);//计算hash值
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;
}
判断key是否为null，特殊处理，在0号索引位置进行遍历，若存在key为null的节点，则直接返回节点的value值。若key不为null，则对key进行哈希，并找到在哈希表中的索引位置，遍历该索引位置的链表，判断key是否存在，存在则直接返回value值，不存在则返回null值。
366
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
