Thinking in Java之HashMap源码分析

最新推荐文章于 2023-04-12 15:35:40 发布

LCore

最新推荐文章于 2023-04-12 15:35:40 发布

阅读量7.7k

点赞数 6

分类专栏：【Thinking in Java】菜鸟Thinking in Java 文章标签： HashMap分析负载因子 hash冲突链表数组

本文链接：https://blog.csdn.net/lcore/article/details/8885961

版权

【Thinking in Java】同时被 2 个专栏收录

20 篇文章 0 订阅

订阅专栏

菜鸟Thinking in Java

18 篇文章 8 订阅

订阅专栏

欢迎讨论、交流，转载请注明出处，3Q!

前言

在前面的文章中笔者就Map接口和Map接口的实现原理:内部哈希映射技术做了一个简单的

分析，并且对hashCode方法做了一些阐述。可能有些混乱，不过理解这些是弄懂HashMap

的前提，也能帮助我们更好的解析hashMap的源码。

HashMap类设计

HashMap是基于哈希表的Map接口的非同步实现，它提供所有可选的映射操作，并允许使

用null键和null值。此集合不保证映射的顺序，特别不保证其顺序永久不变。

首先我们先看下HashMap类的头部：

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

对于它的分析就不多做解释了，AbstractMap类主要是帮助我们自定义自己的Map实现类。

1、底层实现

接下来我们看看HashMap的底层是如何实现的。在这之前我们先对数据结构略作分析。

在java语言中，最基本的结构分为两种：其一为数组，其二为模拟指针(引用)说白了就是

链表。所有的数据类型都可以使用上述的两种来构造。

数组的特点是：寻址容易，插入和删除困难；

链表的特点是：寻址困难，插入和删除容易；

思考下：我们能不能结合两者的优点，折中构造一种寻址容易，插入删除也较为容易的

数据结构呢？答案是肯定的了。我们可以构造一种“链表散列”的数据结构，可以理解为链表

的数组，HashMap就是基于其实现的。

从图中可以看出HashMap的底层就是一个数组结构，数组中的每一项又是一个链表。那么

究竟是不是这样呢？我们看源码吧。

 /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */ 
 transient Entry<K,V>[] table;
 static class Entry<K,V> implements Map.Entry<K,V> {
        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;
        }
    ...........
}

可以看出的是HashMap里面实现了一个静态内部类Entry(记录)，其重要的属性有key、value、next

而HashMap有一个属性是Entrr的数组table。Entry就是table数组中的元素，Map.Entry保存一个键值对

和这个键值对持有指向下一个键值对的引用，如此就构成了链表了。

2、构造方法

/**根据指定容量和负载因子构造HashMap*/ 
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();
    }

    /**根据指定的容量和默认的负载因子构造HashMap*/
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    //默认的空的构造器
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
    /**通过指定一个Map对象进行构造*/
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        putAllForCreate(m);
    }

上述构造函数可以看出的是就是对table数组进行空间分配，至于那个负载因子到底是怎么回事

这里我们先不做解释。

3、存储元素

对于HashMap的存储元素的方法由多个，这里我们就put方法做下分析吧：

public V put(K key, V value) {
    // HashMap允许存放null键和null值。
    // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。
    if (key == null)
        return putForNullKey(value);
    // 根据key的keyCode重新计算hash值。
    int hash = hash(key);//注意这里的实现是jdk1.7和以前的版本有区别的
    // 搜索指定hash值在对应table中的索引。
    int i = indexFor(hash, table.length);
    // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。
    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;
        }
    }
    // 如果i索引处的Entry为null，表明此处还没有Entry。
    modCount++;
    // 将key、value添加到i索引处。
    addEntry(hash, key, value, i);
    return null;
}

思考1：（未发生hash冲突情况下）

table是线性数组，是如何实现随机存储的呢？
这里是通过下面两行代码来实现的

    int hash = hash(key);//注意这里的实现是jdk1.7和以前的版本有区别的
    // 搜索指定hash值在对应table中的索引。
    int i = indexFor(hash, table.length);

通过hash方法的到key对象的哈希码，在通过indexFox()方法生成索引。具体如下：

/**产生哈希码*/
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).
        /*加入高位计算，防止低位不变，高位变化是引起hash冲突*/
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
/**产生索引，由于索引产生是不确定的，因此也就造成了HashMap顺序的不确定性。
   需要注意的是不同的hash产生的索引完全有可能相同的
  该方法的实现十分的巧妙，它通过h & (length-1)来的到对象保存的
  索引，有可知道底层数组为2的n次方，这在速度上就有了明显的优化
  */
static int indexFor(int h, int length) {
        return h & (length-1);
    }

通过上述代码我们可以很深刻的理解到，通过key值的hashCode方法返回的hash码，来产生

索引i。如果table[i]为null，则此处没有键值对，可以直接插入。如果table[i]！=null则此处有元素

则上面的for循环就是存储的新的元素：

 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;
            }
        }

Tips:上述的key对象的hashCode我们应该主动的去重写，是的其和equals方法的逻辑一致性，

例如一个具体的对象作为一个key，我们通过内容判断是否相等(equals重写)，这时我们应该要

主动的去重写hashCode方法，让其和equals方法一样的逻辑结果。如若不然的话，我们认为相等

的key会覆盖，却因为没有重写hashCode实际上没有覆盖！

因为实际我们用String作为key的比较多，也就没有太过注意上述情况。

下面的就是一个错误例子

package com.kiritor;

public class Student {
	String name;

	public Student(String aa) {
		// TODO Auto-generated constructor stub
		name = aa;
	}

	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		return this.name.equals(((Student) obj).name);
	}
    
  public static void main(String[] args) throws InterruptedException {
        
      HashMap<Student, Object> hashMap = new HashMap<>();
      hashMap.put(new Student("AA"), "HEHE");
      hashMap.put(new Student("AA"), "HEHE");
      System.out.println(new Student("AA").name.equals(new Student("AA").name));
      System.out.println(hashMap.size());
   
    }
      
 }

结果为：true 2 明显和我们的初衷背离了，因此这是我们序注意的地方。

思考2：hash冲突

一个有意思的情况出现：

我们仔细思考可以发现的是不同的hashCode产生的索引可能相同，这就是hash冲突，如何解决

这一问题呢？其实这里就是“链表数组”的IMBA之处了。详细的处理情况还是在for循环中。

 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;
        }
    }

简单的分析下：假设table[0]！=null，其键为key1,当第二次插入的时候key2的哈希码虽然和key1不同，

但是获得的索引却是0，产生了hash冲突。进入for循环体，由于key1、key2的哈希不同，所以if判断为false

之后key1=key1.next(说法不准，这里直接就以key当做键值对元素吧)，再然后执行for之后的插入语句

    // 如果i索引处的Entry为null，表明此处还没有Entry。
    modCount++;
    // 将key、value添加到i索引处。
    addEntry(hash, key, value, i);
    return null;

key2被插入进key1的位置，同时key2.next指向的是key1，ok看明白了吗？这样hash冲突的问题就

通过链表数组的形式被解决了。简单的用图形展示

这里HashMap解决hash冲突的方法就是通过链地址法来的。

这里笔者也给出其他的冲突解决方式，有兴趣的朋友可以研究下：

1）开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）

2）再哈希法

3）链地址法

4）建立一公共溢出区

4、读取元素

说完了元素的存储，我们来看看，HashMap是如何来读取元素的吧，这里我们简要的分析

下get(key)方法

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

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

对于key为空值的情况，我们就不在详述了，读者朋友可自行参阅jdk源码。

接下来进入getEntry(key)方法体里面去。

  final Entry<K,V> getEntry(Object key) {
        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;
    }

嘿，这不和存储的方式有些相似吗，由hash的到索引，如果索引位置为空，就不存在此key

values返回的就是空。如若索引位置不为空，该位置下可能是一条链，找到这条链里面可key的

hash相同的key，返回其对应的values。呵呵，取元素的方法是否简单多了呢？