jdk1.7的hashmap是根据数组+链表的方式进行存储的。
数组下标是根据计算的hash值和数组长度算出来的（防止越界）。
链表存储的方式是头插法。
下面是我整理出的put时的流程图：
hashmap的重要属性：
//1. HashMap的K, v的值,在创建对象的时候确定: K: Integer V:String
//HashMap的父类AbstractMap已经实现类Map接口,但是源码中又单独实现了Map接口
//这个操作就是-一个多余的操作-->集合的创作者 承认了
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//默认初始化化容量,即16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量，即2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//HashMap内部的存储结构是一个数组，此处数组为空，即没有初始化之前的状态
static final Entry<?,?>[] EMPTY_TABLE = {};
//空的存储实体
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//HashMap的元素数目
transient int size;
//HashMap下次扩容是的阀值，threshold = 初始容量 * 加载因子
int threshold;
//HashMap的加载因子
final float loadFactor;
//修改次数
transient int modCount;
//最大的扩容阈值
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
//hash总值，默认为0，目的使hash更复杂，结果更散列
transient int hashSeed = 0;
构造方法：
//容量取16，加载因子取0.75，构造HashMap
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//通过加载因子构造HashMap,容量取默认值，即16
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//通过初始容量和加载因子构造HashMap
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)//初始容量不能小于0
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)//最大容量不能大于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();//这个实现为空，LinkedHashMap会使用
}
//通过其他Map来初始化HashMap,容量通过其他Map的size来计算，装载因子取0.75
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);//添加m中的元素
}
初始化HashMap方法：选取初始加载容量为：大于等于传入容量的2的幂次方。比如传入容量为6，那么实际初始化容量为8。
//初始化HashMap的底层数据结构
private void inflateTable(int toSize) {
int capacity = roundUpToPowerOf2(toSize);//选取合适的容量值
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//选取合适的threshold（扩容阀值）
table = new Entry[capacity];//初始化底层数据结构
initHashSeedAsNeeded(capacity);//选择合适的Hash总值，这里和虚拟机的配置有关
}
//选择合适的容量值，容量值取大于等于最接近number的2的冪数
private static int roundUpToPowerOf2(int number) {
// 如果传入容量超出了最大值，则采用最大值。如果小于1，则容量使用1
// 其余情况：容量 <= 最接近容量的2的幂数，比如 容量 10=>16, 16=>16
/*
* 假设传入值为10：
* 首先，计算(number - 1) << 1，也就是(10-1) << 1 = 18，number - 1是为了防止特殊情况，比如number = 16
* 然后调用Integer.highestOneBit(18)，最终返回为16.
* 二进制 十进制
* 0001 0010 18
* 0001 1111 31 首先，将最高位之后所有位转换为1
* 0000 1111 15 右移一位之后，相减也就是 （11111）2 - （1111）2 => 31 - 15 = 16
* ----------------------------
* 0000 1111 16
* */
return number >= MAXIMUM_CAPACITY ?
MAXIMUM_CAPACITY : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
hash的计算方式：
//计算key的Hash值，这里针对String类的Key优化了Hash函数
final int hash(Object k) {
int h = hashSeed; //hash总值，初始值为0
if (0 != h && k instanceof String) {//这里针对String优化了Hash函数，是否使用新的Hash函数和Hash因子有关
return sun.misc.Hashing.stringHash32((String) k);
}
/*
* 这里将获取到的hashCode值>>>和^，是为了更好的平均分配定位hash桶位置索引，让高位的二进制数参与到定位hash桶位置的运算中。
* */
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
使用下面的方法计算放在数组的下标位置，为了防止根据hash值计算出来的下标越界：
//根据Hash值和Hash表的大小选择合适的Hash桶
static int indexFor(int h, int length) {
/*
* 返回需要保证两个条件：
* 1.返回值小于length
* 2.分配平均
* 假设hash为17，传入容量为10，经过计算之后的容量为16，那么返回值就为 17 & (16 - 1)
* 二进制 十进制
* 0001 0001 17
* 0000 1111 15
* &
* -----------------------------
* 0000 0001 1
* */
return h & (length-1);
}
put方法
如果底层数组为空，则会先初始化底层数组，默认容量为16。定位Hash桶位置，并且遍历该链表下的所有节点，如果有节点和插入节点的key相同，就覆盖该节点，并且返回旧的value，如果没有key相同，那么就会采用头插法，将该节点插入。
如果key为空，则执行空的逻辑，说明HashMap可以存放key为null的元素，该元素默认存放在数组下标为0的链表中。
//添加元素
public V put(K key, V value) {
if (table == EMPTY_TABLE) {//具体看：容量计算方法
inflateTable(threshold);
}
if (key == null)//如果key为空，则执行空的逻辑，说明HashMap可以存放key为null的元素
return putForNullKey(value);
int hash = hash(key);//获取key的Hash值
int i = indexFor(hash, table.length);//定位Hash桶
//如果放入的数组的位置上没有元素的话，那么直接添加就行了,不用走这个for循环
for (Entry<K,V> e = table[i]; e != null; e = e.next) {//定位到hash桶的链表上，是否有key相同的元素，如果有返回并修改旧值
Object k;
//发生哈西碰撞的时候,会先比较哈希值
//比较key是否是一一个对象，如果key是一-个对象的话,equals就不比较了
//如果不是同一个对象,会比较equals方法
//如果hash值- -样，equals方法比较的结果也一-样，那么才会走这个if方法:
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {//hash相同，并且key相同
V oldValue = e.value; //获取老的value
e.value = value;//新值覆盖旧值-->只替换value不替换key
e.recordAccess(this);//调用value的回调函数，其实这个函数也为空实现
return oldValue;//返回旧值
}
}
modCount++;//更新修改次数
addEntry(hash, key, value, i);//添加到对应Hash桶的链接表中，头插法
return null; //如果该key以前没有被添加过，则返回null
}
addEntry()添加新元素:
void addEntry(int hash, K key, V value, int bucketIndex) {
// 当数组的size >= 扩容阈值，触发扩容，size大小会在createEnty和removeEntry的时候改变
if ((size >= threshold) && (null != table[bucketIndex])) {
// 扩容到2倍大小，后边会跟进这个方法
resize(2 * table.length);
// 扩容后重新计算hash和index
hash = (null != key) ? hash(key) : 0;
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++; //标记table数组中已存储key-val的个数，为了判断是否需要扩容
}
hash的扩容：
//执行扩容
void resize(int newCapacity) {
Entry[] oldTable = table;//老的数据
int oldCapacity = oldTable.length;//获取老的容量值
if (oldCapacity == MAXIMUM_CAPACITY) {//老的容量值已经到了最大容量值
threshold = Integer.MAX_VALUE;//修改扩容阀值
return;
}
//新的结构
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));//将老的数据拷贝到新的结构中。initHashSeedAsNeeded为是否使用hash总值，与虚拟机配置有关，默认为false
table = newTable;//修改HashMap的底层数组
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);//定位Hash桶，计算的结果可能为：初始位置 或者 初始位置 + 扩容量
e.next = newTable[i];//扩容插入也会采用头插法，与旧的hash桶相比链表的顺序可能会被颠倒，并且分散到 初始位置 和 初始位置 + 扩容量两个位置中
newTable[i] = e;
e = next;
}
}
}
get方法：
public V get(Object key) {
if (key == null)
return getForNullKey();
//获取Key为key的键值对
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
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;
}
private V getForNullKey() {
if (size == 0) {
return null;
}
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
扫一扫
1028
到【灌水乐园】发言
