原理说明
数组是最基本的数据结构,ArrayList内部就是数组实现的,下标定位位置,然后在数组下标位置存放元素,每添加一个元素,下标就+1,map和list有一点相似,就是内部也有个数组, 它通过key存放获取对象,以key计算数组下标。使用hashCode的话,得出的值很大,很容易是数组越界,可以使用取余的方式减小这个,那么余多少呢?比如下标是0-7,那么我们可以余它的数组大小(length),hashCode是随机的,得出的下标也是随机的,这也使得数组下标随机平均。
但还有一个问题,hashCode是随机的,但在取余之后得到的值很可能是相同的,比如第一次你存了kk1: vv1
,第二次存放kk2: vv2
计算key后得出的位置也是同一个位置,那么在同一下标有两个对象了,那么可以链表去解决这个问题;再来一个,也是计算得到同一个下标,考虑一个问题,是插入头部比较快还是尾部比较快?
如果是头插法,只需要修改新节点的next的下一个节点指针就行了,而如果是尾插,那么还需要遍历链表,然后修改尾部的指针,显然,尾插法的效率不是很高,map里就是用的头插法,头插法只有next的元素,这是查找下一个元素使用的,它没有向上查找的方式,它的查找方式也是先计算数组下标,得到下标后,找到对应的链表,然后遍历的:
上面只是对map的一个原理说明,并不严谨。
源码解析
这里从HashMap的源码上去看HashMap这个结构,从源码分析理解。
它的结构是:
entry数组,entry是链表;
静态常量
HashMap里有这些个属性:
// 默认初始容量 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 空数组对象
static final Entry<?,?>[] EMPTY_TABLE = {};
// 内部数组,
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
// map长度
transient int size;
// 阈值,是否扩容根据这个判断:threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1) => capacity * loadFactor
int threshold;
// 加载因子,扩容计算用到
final float loadFactor;
// 修改计数
transient int modCount;
// hash种子,计算hash值用到,为了是计算的hashCode更加的散列随机。
transient int hashSeed = 0;
构造函数
看的构造方法,这里传进了两个值,这两个值都是默认给定的,在上面的变量中可以找到,分别是16和0.75f
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
那么在看里面的一个逻辑:
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;
// 阈值
threshold = initialCapacity;
// 这个init没什么作用
init();
}
构造方法中是做了简单初始化(对默认值进行设置),但并未对内部的结构初始化,所以,它new的时候,并不进行任何的操作,只有当它使用时才会进行进一步的初始化(对内部数组初始化);
put操作
接着看put方法(添加操作):
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// key == null 的情况
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
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;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
初始化数组
put方法一进来就是这个,初始化内部数组,这里的threshold
是在构造方法中初始化的一个默认值,这个值是16。
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
进入inflateTable
方法,这个方法它有3个操作,首先是一个计算容量的方法roundUpToPowerOf2
,然后计算阈值threshold
,然后是计算哈希种子。
private void inflateTable(int toSize) {
// Find a power of 2 >= toSize
int capacity = roundUpToPowerOf2(toSize);
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
这里通过roundUpToPowerOf2
方法产生一个初始化的数组大小,跟进roundUpToPowerOf2方法,看看它是怎么生成的:
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
- 首先是判断number(阈值)是否是大于等于最大容量值,
- number肯定是小于等于的
- 所以是走这个代码:(number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1
上面这一串就重点看:
Integer.highestOneBit((number - 1) << 1)
默认的初始化,number就是16
public static int highestOneBit(int i) {
// HD, Figure 3-1
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return i - (i >>> 1);
}
这个是计算小于等于当前值的二次方数,比如下面给定值为17,其结果是16,给定值是18,19,20都会是16,
i=17 =>
0000 0000 0000 0000 0000 0000 0001 0001
(i >> 1) =>
0000 0000 0000 0000 0000 0000 0000 1000
i |= (i >> 1) =>
0000 0000 0000 0000 0000 0000 0001 1000
…
i |= (i >> 16) =>
0000 0000 0000 0000 0000 0000 0001 1111
i - (i >>> 1) =>
0000 0000 0000 0000 0000 0000 0001 1111
0000 0000 0000 0000 0000 0000 0000 1111
0000 0000 0000 0000 0000 0000 0001 0000
了解了highestOneBit
方法后,再看上一层代码,为什么要-1,和左移1位?
Integer.highestOneBit((number - 1) << 1)
原因是为了得到小于等于指定值的最大2次方数
-
我们要得到的是一个大于等于在给定值的一个2的幂次方数,
highestOneBit
得到的是一个小于等于给定值的幂次方数,所以左移1位;假如我们给定值为17,那么要得到的结果应该是32,如果我们不左移,最后得到的值就会是16 -
假如给定值是16,要得到结果应该是16,左移1位得到32,所以左移前-1得到15,在左移得到30才能得到16
roundUpToPowerOf2
注释写着要2的每次方数,那为什么要2的幂次方数呢(为什么map的长度需要2的幂次方)?
可以看看这篇博客,比较详细: https://blog.csdn.net/LLF_1241352445/article/details/81321991?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase
其结论就是:为了能够是hash计算出的key,能够更加平均的分散在数组的各个索引下。
添加对象
接着put方法;
if (key == null)
return putForNullKey(value);
private V putForNullKey(V value) {
// 遍历内部数组的第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;
// 这个方法不管他,跟hashMap没有关系,这个是给它子类(LinkedHashMap)写的。
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
key==null的话,那么它对应的hash值就是0,对应的索引也是0;
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;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
再回到put方法:
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
// 初始化数组
inflateTable(threshold);
}
// 第一种情况key == null
if (key == null)
return putForNullKey(value);
// 计算hash值
int hash = hash(key);
// 这里就是hash & (table.length - 1)
// 计算数组下标
int i = indexFor(hash, table.length);
// 遍历数组下标对应的链表
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 判断key计算的hash值相同,且key值相同
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
// 设置新值,获取旧值并返回
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 每次修改+1
modCount++;
// 如果没有找的对应的,就新增一个
addEntry(hash, key, value, i);
return null;
}
上面这个modCount
这个标识是一种快速失败的机制,多线程下,一个线程在遍历,一个线程在新增或删除,遍历到了第3个,而删除了第二个,而这时已经遍历了3个了,但是第二个被删除了,总数不对,如果取值,也取不到,所以每次修改都会记录,在遍历时会去判断,不一样会报错。
下面是添加一个entry
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;
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++;
}
这里是直接获取到数组下标的元素,然后new Entry,这个构造方法中是将e(原数组下标的对象,也就是数组下标对应的链表entry)给了新entry的next(指针),这也就是我们开篇是说的头插法。
扩容
扩容就是扩大数组容量大小,那么就会有重新计算它的各个值,如阈值、容量;当存储数量大于等于阈值时,就会触发扩容,过程就是重新创建一个数组,然后再把元素转移。
看看数组元素转移的方法,这个也比较简单的,就是重新计算下标
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;
// 重新计算hash值
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
// 计算数组下标
int i = indexFor(e.hash, newCapacity);
// 转移到新数组
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
get操作
而get方法相对简单些:
第一种是获取key = null的value
public V get(Object key) {
if (key == null)
// key == null 的情况
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
private V getForNullKey() {
if (size == 0) {
return null;
}
// 遍历数组第一个位置的链表
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
// 找到key == null 的元素并返回
if (e.key == null)
return e.value;
}
return null;
}
第二种是获取key != null的value;
这种方式通过key计算出hash值,然后在计算数组下标,拿到对应的entry,然后遍历entry,通过判断hash值和equals来判断是否我们要的对象。
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;
// 判断hash值、key相同并返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}