最近朋友去面试被问了些hashmap相关的问题,hashmap的初始容量啊,什么操作最耗时等,之前看过hashmap的源码,正好这里也在总结下。
主要围绕下面几个点:
- HashMap是由数组+链表(jdk8 升级为红黑树)结构实现
- HashMap 在第一次put的时候才会去分配内存(ArrayList也是在第一次add的时候)
- HashMap 默认数组大小是16
- HashMap 每次扩容之后大小都为2的倍数
- HashMap在达到容量阀值(threshold=capacity*loadFactor)时候会进行扩容
- HashMap如何进行扩容
代码参考jdk1.7
HashMap是由数组+链表(jdk8 升级为红黑树)结构实现
这个是再put时候会初始化一个数组,在key hash冲突时候同一bucket加入新value
// 初始化数组private void inflateTable(int toSize) { int capacity = roundUpToPowerOf2(toSize); threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); table = new Entry[capacity]; initHashSeedAsNeeded(capacity); }
public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } // key 为null时候直接put 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; // 在hash值相同&&key equals时候进行值替换 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } // 否则添加新value modCount++; addEntry(hash, key, value, i); return null; }
HashMap 在第一次put的时候才会去分配内存(ArrayList也是在第一次add的时候)
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(); }
这是HashMap的构造函数,看一看到这里只是初始化了loadFactor跟threshold 这两个参数,而在上一个分析中第一次put元素的时候会执行inflateTable函数来初始化数组:
table = new Entry[capacity];进行内存分配 HashMap 默认数组大小是16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 HashMap 每次扩容之后大小都为2的倍数
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); }
在调用addEntry添加新元素的方法时,会判定size是否达到了临界值,如果到了则进行数组扩容,回调用resize方法可以看到新的容量为原始容量*2
HashMap如何进行扩容
static int indexFor(int h, int length) { // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2"; return h & (length-1); }
这段代码是进行数组下标计算的
resize代码如下
JKD1.7 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)); table = newTable; threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); } /** * Transfers all entries from current table to newTable. */ 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); e.next = newTable[i]; newTable[i] = e; e = next; } } }
JDK1.8中这里会涉及到HashMap涉及很巧妙的一个点。由于 table.length 也就是capacity 肯定是2的N次方,使用 & 位运算意味着只是多了最高位,这样就不用重新计算 index,元素要么在原位置,要么在原位置+ oldCapacity
如果增加的高位为0,resize 后 index 不变,如图所示:
如果增加的高位为1,resize 后 index 增加 oldCap,如图所示:
这个设计的巧妙之处在于,节省了一部分重新计算hash的时间,同时新增的一位为0或1的概率可以认为是均等的,所以在resize 的过程中就将原来碰撞的节点又均匀分布到了两个bucket里。
do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null);
时间: 2024-10-28 11:04:17