第一次实习面试的时候,小房间里面试官拿着一本本子,上来就告诉我自己是做Java的,然后问了我很多Java基础,当从HashMap如何使用到怎么实现的时候,我就两眼懵逼了,当问到安卓的Context是干什么的时候,我的内心直接被击中了。虽然写了好几个月的程序,却只停留在会用的基础上,而没去知其所以然,太脸红了。这次面试打开了我对程序语言执着研究的大门,还是菜鸟的我感觉到能问出这种问题,还如此谦虚的人真是厉害,怀抱着大神带我飞的心情,几乎热泪盈眶的我欣然带着这份offer,准备跟着大神大干一场。结果当我入职的事后才知道,大神在我来的前几天就去支付宝了...言归正传,我就整理八经研究一下这个HashMap。
HashMap
HashMap是程序编写过程中,再平常不过的一个集合类,通常通过他的put(key,value)和get(key)方法来存取数据,数据存取的类型非常多样,而且允许key和value为null。直接上源码：
HashMap
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,
Cloneable, Serializable { ... }
AbstractMap
public abstract class AbstractMap<K,V> implements Map<K,V> { ... }
HashMap继承于AbstractMap,Map定义了键值对的映射规则。AbstractMap内部也也实现了Map接口,
这是为什么嘞？难道是为了强调吗,或者是反射getInterfaces的时候能够直接获取到Map,这里不是和明白,后续再补吧。
构造方法
HashMap的构造方法四个
Ps: 全局变量中已经指定默认的加载因子0.75,初始容量16
public HashMap(int initialCapacity, float loadFactor)
<!--构造一个带指定初始容量和默认加载因子(0.75)的空HashMap-->
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
<!--构造一个具有默认初始容量(16)和默认加载因子(0.75)的空HashMap-->
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(Map<? extends K, ? extends V> m){
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
}
殊途同归,最终都指向了第一个构造方法。嗯,我们来看一下。
public HashMap(int initialCapacity, float loadFactor)
这里有初始容量,加载因子两个参数,影响HashMap性能。
初始容量 是哈希表在创建时的容量。
加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时,通过调用rehash 方法将容量翻倍。
以下内容来自百度对于他们的理解：
比如说向水桶中装水,此时HashMap就是一个桶, 这个桶的容量就是加载容量,而加载因子就是你要控制向这个桶中倒的水不超过水桶容量的比例,比如加载因子是0.75 ,那么在装水的时候这个桶最多能装到3/4 处,超过这个比例时,桶会自动扩容。因此,这个桶
最多能装水 = 桶的容量 x 加载因子。
如果桶的容量是40,加载因子是0.75
那么你的桶最多能装40 x 0.75 = 30的水,如果你装了30的水还想继续装水,那么就该用大一点的桶,调用rehash就是负责增加桶的容量的方法。
数据结构
Java中最常用的两种结构是数组和模拟指针(引用),几乎所有的数据结构都可以利用这两种来组合实现,HashMap也是如此。实际上HashMap是一个“链表散列”,网上扒取了一张结构图：
HashMap底层还是数组,只是数组的每一项都是一条链,initialCapacity 代表数组长度。
来吧,看看构造函数的内容:
public HashMap(int initialCapacity, float loadFactor) {
<!-- 初始容量必须大于或者等于0 -->
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
<!-- 初始容量不能 > 最大容量值,HashMap的最大容量值为2^30 -->
if (initialCapacity > MAXIMUM_CAPACITY) {
initialCapacity = MAXIMUM_CAPACITY;
} else if (initialCapacity < DEFAULT_INITIAL_CAPACITY) {
initialCapacity = DEFAULT_INITIAL_CAPACITY;
}
<!-- 加载因子不能小于0 -->
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
threshold = initialCapacity;
<!-- 这个方法留给子类重写,里面什么都没有 -->
init();
}
存储数据
数据存储用的是put(k,v)的方式
public V put(K key, V value) {
// 如果表是空的 就新建一个HashTable
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// key可以是null,调用putForNullKey方法,保存null与table第一个位置中
if (key == null)
return putForNullKey(value);
// 获取key的哈希
int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);
// 计算key hash 值在 table 数组中的位置
int i = indexFor(hash, table.length);
// 迭代找出key的位置,为了得到 value
for (HashMapEntry<K, V> e = table[i]; e != null; e = e.next) {
Object k;
// 如果key重复了 返回老的value （所以put的结果是个object）
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 添加一次修改
modCount++;
// 将key、value添加至i位置处 替换
addEntry(hash, key, value, i);
return null;
}
计算哈希值的方法
static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
我们知道对于HashMap的table而言,数据分布需要均匀（最好每项都只有一个元素,这样就可以直接找到）,不能太紧也不能太松,太紧会导致查询速度慢,太松则浪费空间。计算hash值后,怎么才能保证table元素分布均与呢？我们会想到取模,但是由于取模的消耗较大,HashMap是这样处理的：调用indexFor方法。
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);
}
HashMap的底层数组长度总是2的n次方,在构造函数中存在：capacity <<= 1;这样做总是能够保证HashMap的底层数组长度为2的n次方。当length为2的n次方时,h&(length - 1)就相当于对length取模,而且速度比直接取模快得多,这是HashMap在速度上的一个优化。
取数据
数据获取用的是get(key)的形式。
public V get(Object key) {
<!--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;
}
for (HashMapEntry<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 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
for (HashMapEntry<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;
}
Entry是Map接口内的一个接口,他的作用就是包装一个map的节点,这个节封装了key,value,以及别的值（比如hashmap中的哈希码和next指针）,方便对Map的操作。
总结
由此看出,数据结构基础不好,看这个真费劲。明白是明白,但是真叫你一点点写出来,是想扑街的。
HashMap基于hashing原理，我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，然后找到bucket位置来储存值对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会储存在链表的下一个节点中。 HashMap在每个链表节点中储存键值对对象。
当两个不同的键对象的hashcode相同时会发生什么？ 它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。
因为HashMap的好处非常多，我曾经在电子商务的应用中使用HashMap作为缓存。因为金融领域非常多的运用Java，也出于性能的考虑，我们会经常用到HashMap和ConcurrentHashMap。
