HashMap源码深入解析

HashMap是Java Colletion Framework的重要成员,HashMap是Map接口的常用实现类,在我们平常开发时会经常使用到Map,在我们面试的时候也会问到map的存储原理,今天特地来总结一下;

创建HashMap

HashMap<String , Double> map = new HashMap<String , Double>(); 
使用HashMap那么首先你得去创建一个HashMap,在创建的时候会发生什么事情啦?让我们跟着源码去看一下;

  public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
这里会给一个默认的初始化容量值,这个值是
static final int DEFAULT_INITIAL_CAPACITY = 16;
那第一个参数是默认初始化容量值,第二个参数就是默认最大加载因子,好了,我们也看一下这个值是多少;

 static final float DEFAULT_LOAD_FACTOR = 0.75f;

那么这两个数字,有什么特殊的含义啦,这里我们来理解总结一下;

HashMap实现了Map接口,它在初始化的时候会有一个默认的初始化容量值,根据版本不同这个值也有可能会不一样。然后还会有一个初始化的默认最大加载因子,所谓最大加载因子是指,当map里面的数据超过了这个界限的时候会自动去扩大容量;

说的通俗一点啊 比如说你要装水 你首先找个一个桶 这个桶的容量就是加载容量,加载因子就是比如说你要控制在这个桶中的水要不超过水桶容量的多少,比如加载因子是0.75 那么在装水的时候这个桶最多能装到3/4 处, 这么已定义的话 你的桶就最多能装水 = 桶的容量 * 加载因子
如果桶的容量是40 加载因子是0.75 那么你的桶最多能装40*0.75 = 30的水 
如果你要装的水比30 多 那么就该用大一点的桶;

再接着往下走可以看到

<pre name="code" class="java">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);  
  
    // Find a power of 2 >= initialCapacity  
    // 这里需要注意一下  
    int capacity = 1;  
    while (capacity < initialCapacity)  
        capacity <<= 1;  
  
    // 设置加载因子  
    this.loadFactor = loadFactor;  
    // 设置下次扩容临界值  
    threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);  
    // 初始化哈希表  
    table = new Entry[capacity];  
    useAltHashing = sun.misc.VM.isBooted() &&  
            (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);  
    init();  
}  

 

threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
这段代码前面的都是一些校验而已,不用管,主要从这段开始,默认16的话,乘以0.75就是11.52,然后用了Math.min方法得到最终结果为12,所以这里我们Map的临界值就为12;

可以看到,默认的平衡因子为0.75,这是权衡了时间复杂度与空间复杂度之后的最好取值(JDK说是最好的),过高的因子会降低存储空间但是查找(lookup,包括HashMap中的put与get方法)的时间就会增加。

这里比较奇怪的是问题:容量必须为2的指数倍(默认为16),这是为什么呢?解答这个问题,需要了解HashMap中哈希函数的设计原理。

哈希函数的设计原理

/**
  * Retrieve object hash code and applies a supplemental hash function to the
  * result hash, which defends against poor quality hash functions.  This is
  * critical because HashMap uses power-of-two length hash tables, that
  * otherwise encounter collisions for hashCodes that do not differ
  * in lower bits. Note: Null keys always map to hash 0, thus index 0.
  */
 final int hash(Object k) {
     int h = hashSeed;
     if (0 != h && k instanceof String) {
         return sun.misc.Hashing.stringHash32((String) k);
     }
     h ^= k.hashCode();
     // This function ensures that hashCodes that differ only by
     // constant multiples at each bit position have a bounded
     // number of collisions (approximately 8 at default load factor).
     h ^= (h >>> 20) ^ (h >>> 12);
     return h ^ (h >>> 7) ^ (h >>> 4);
 }
 /**
  * Returns index for hash code h.
  */
 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);
 }

看到这么多位操作,是不是觉得晕头转向了呢,还是搞清楚原理就行了,毕竟位操作速度是很快的,不能因为不好理解就不用了。

网上说这个问题的也比较多,我这里根据自己的理解,尽量做到通俗易懂。

在哈希表容量(也就是buckets或slots大小)为length的情况下,为了使每个key都能在冲突最小的情况下映射到[0,length)(注意是左闭右开区间)的索引(index)内,一般有两种做法:

  1. 让length为素数,然后用hashCode(key) mod length的方法得到索引

  2. 让length为2的指数倍,然后用hashCode(key) & (length-1)的方法得到索引

HashTable用的是方法1,HashMap用的是方法2。

接着往下走会到

table = new Entry[capacity];
让我们用Debug接着往下走看看;

 final K key;
        V value;
        Entry<K,V> next;
        int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
这是一个匿名内部类,里面的属性有两个泛型的key和value,然后下一个entry类,然后一个hash值;


我们会创建出一个叫做table大小是16的Entry数组。

put操作:

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
这里会首先判断一下我们的key值,如果key为空的话,会执行putForNullKey(value)方法,我们看一下这个方法是什么意思;

private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }
就是说,获取Entry的第一个元素table[0],并基于第一个元素的next属性开始遍历,直到找到key为null的Entry,将其value设置为新的value值。
如果没有找到key为null的元素,则调用如上述代码的addEntry(0, null, value, 0);增加一个新的entry,源码如下

void addEntry(int hash, K key, V value, int bucketIndex) {  
    Entry<K,V> e = table[bucketIndex];  
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
        if (size++ >= threshold)  
            resize(2 * table.length);  
    }  

但是调式中发现一个很奇怪的问题,就是key如果为null的话并不会进入到这个方法里面,这很奇怪。。跟踪一下发现key的值会变成file:///C:/Program%20Files/Java/jdk1.7.0_13/jre/lib/ext/dnsns.jar,有谁知道原因的可以告诉我一下。

当然我们大多数的key都不会为null,所以接着我们的put方法接着往下走就是:

  int hash = hash(key);
key的hashcode()方法会被调用,然后计算hash值。hash值用来找到存储Entry对象的数组的索引。有时候hash函数可能写的很不好,所以JDK的设计者添加了另一个叫做hash()的方法,它接收刚才计算的hash值作为参数。代码如下

final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

继续往下走就到了int i = indexFor(hash, table.length);

indexFor(hash,table.length)用来计算在table数组中存储Entry对象的精确的索引。

下面就要进行我们的迭代链表并替换更新操作了

<pre name="code" class="java"> //这里的循环是关键
    //当新增的key所对应的索引i,对应table[i]中已经有值时,进入循环体
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        //判断是否存在本次插入的key,如果存在用本次的value替换之前oldValue,相当于update操作
        //并返回之前的oldValue
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    //如果本次新增key之前不存在于HashMap中,modCount加1,说明又新增了一个table值,并且把count++;
    modCount++;
    addEntry(hash, key, value, i); //这里执行插入操作
    return null;
}


 这里有一个疑问,就是为什么要返回一个null,这个null到底有什么寓意,我估计可能其它继承自MAP的方法会返回一些实际的值,所以这里继承了就返回一个无意义的null;我觉得这里返回一个有意义的值是不是会好一点,比如我添加更新结构体了,就返回1,没有更新结构体就返回0; 

Get:

这里来看一下Get操作的源码

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

  1. 对key进行null检查。如果key是null,table[0]这个位置的元素将被返回。

  2. key的hashcode()方法被调用,然后计算hash值。

  3. indexFor(hash,table.length)用来计算要获取的Entry对象在table数组中的精确的位置,使用刚才计算的hash值。

  4. 在获取了table数组的索引之后,会迭代链表,调用equals()方法检查key的相等性,如果equals()方法返回true,get方法返回Entry对象的value,否则,返回null。


总结一下:

  • HashMap有一个叫做Entry的内部类,它用来存储key-value对。
  • 上面的Entry对象是存储在一个叫做table的Entry数组中。
  • table的索引在逻辑上叫做“桶”(bucket),它存储了链表的第一个元素。
  • key的hashcode()方法用来找到Entry对象所在的桶。
  • 如果两个key有相同的hash值,他们会被放在table数组的同一个桶里面。
  • key的equals()方法用来确保key的唯一性。
  • value对象的equals()和hashcode()方法根本一点用也没有。

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 成长之路 设计师:Amelia_0503 返回首页