【java集合类】HashMap-带你彻底搞定HashMap原理

最新推荐文章于 2022-09-05 13:58:18 发布

原创最新推荐文章于 2022-09-05 13:58:18 发布 · 976 阅读

1 ·

CC 4.0 BY-SA版权

java开发专栏收录该内容

18 篇文章

订阅专栏

本文深入探讨哈希表的基本概念及其在Java中HashMap的具体实现。解析哈希表的存储结构、哈希函数的设计原理及冲突解决策略。详细介绍HashMap的工作机制，包括内部结构、主要方法的实现原理以及扩容机制。

#1、基本概念：

惯例：我喜欢一开始把一篇文章涉及到的关键概念在文章开头就交代清楚，这样再小白的读者都能读懂文章。

哈希表【散列表】：
1. 采用散列技术将记录存储在一块连续的存储空间中，这块连续的储存空间称为哈希表或者散列表。
2. 哈希表里存储的是关键码值(Key value)类型数据，比如HashMap中存的就是Entry对象。
3. 不是传统意义上的数组，可以理解为一开始固定容量固定位置的数组。ps：个人理解，表达可能不清楚，有可能让读者误解，在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)。
哈希函数【计算散列地址的方法】：我们通过把当前元素的关键字通过某个函数映射到哈希表中的某个具体位置，通过哈希表数组下标一次定位就可完成操作；其中，这个映射函数f一般称为哈希函数。

存储位置 = f(关键字)

哈希冲突：当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。

比如：当key1 不等于 key2时，但是f(key1) = f(key2)，这种现象称之为哈希冲突。key1与key2也称之为这个散列函数的同义词。

负载因子【加载因子】： 负载因子= 实际填入表中的记录个数 / hash表的长度。
1. 加载因子是表示Hash表中元素的填满的程度.若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了。
2. 冲突的机会越大,则查找的成本越高.反之,查找的成本越小.因而,查找时间就越小。
3. 因此,必须在 "冲突的机会"与"空间利用率"之间寻找一种平衡与折衷. 这种平衡与折衷本质上是数据结构中有名的"时-空"矛盾的平衡与折衷。
容量：哈希表中可以装填的最大数量，也称hash表的长度。

2、HashMap：

##2.1、HashMap基本介绍:
这里写图片描述

HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；
如果定位到的数组包含链表，对于添加操作，其时间复杂度依然为O(1)，因为最新的Entry会插入链表头部，仅需简单改变引用链即可，而对于查找操作来讲，此时就需要遍历链表，然后通过key对象的equals方法逐一比对查找。
所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

##2.2、Hash表内部讲解：
HashMap中的Hash表是Entry数组，Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。

//HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂。
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE ;

//实际存储的key-value键值对的个数
transient int size;
	
//阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，threshold一般为 capacity*loadFactory。
int threshold;
	
//负载因子，代表了table的填充度有多少，默认是0.75
final float loadFactor;
	
//用于快速失败，由于HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），需要抛出异常ConcurrentModificationException。
transient int modCount;

//每个Hash表中的Entry数组：
static class Entry<K,V> implements Map.Entry<K,V> {
	final K key;  
	V value;  
	Entry<K,V> next;//存储解决Hash冲突的单链表中的下一个Entry的引用变量
	int hash;//key的hash值，对key的hashcode值进行hash()运算后得到的值，存储在Entry，避免重复计算
	 }

##2.3、构造函数：

HashMap()：  //构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity)：//构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity, float loadFactor)：//以指定初始容量、指定的负载因子创建一个 HashMap。

public HashMap(int initialCapacity, float loadFactor) {
	        //此处对传入的初始容量进行校验，最大不能超过MAXIMUM_CAPACITY = 1<<30(230)
	        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方法在HashMap中没有实际实现，不过在其子类如 linkedHashMap中就会有对应实现
	    }

**注意：**在常规构造器中，没有为数组table分配内存空间（有一个入参为指定Map的构造器例外），而是在执行put操作的时候才真正构建table数组。

##2.4、源码解析：
###2.4.1、put（）：

public V put(K key, V value) {
	        //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），
	               //入参为threshold，此时threshold为initialCapacity 默认是1<<4(24=16)
	        if (table == EMPTY_TABLE) {
	            inflateTable(threshold);
	        }
	       //如果key为null，存储位置为table[0]或table[0]的冲突链上
	        if (key == null)
	            return putForNullKey(value);
	        int hash = hash(key);//对key的hashcode进一步计算，确保散列均匀
	        int i = indexFor(hash, table.length);//获取在table中的实际位置
	        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
	        //如果该对应数据已存在，执行覆盖操作。用新value替换旧value，并返回旧value
	            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++;//保证并发访问时，若HashMap内部结构发生变化，快速响应失败
	        addEntry(hash, key, value, i);//新增一个entry
	        return null;
	    }

注意：
1、确定key的hash表下标的步骤：
• 计算key的hashcode值。
• 通过哈希算法hash（）来对key的hashcode值进行一系列的位运算【很多亦或^运算】得到key的hash值，以便散列均匀。
• 再通过indexFor（）方法来对hash算法计算出来的值进行处理来最终确定key在哈希表中的下标值。

//这是一个神奇的函数，用了很多的异或，移位等运算，对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀
	final int hash(Object k) {
	        int h = hashSeed;
	        if (0 != h && k instanceof String) {
	            return sun.misc.Hashing.stringHash32((String) k);
	        }
	
	        h ^= k.hashCode();
	
	        h ^= (h >>> 20) ^ (h >>> 12);
	        return h ^ (h >>> 7) ^ (h >>> 4);
	    }
	
	static int indexFor(int h, int length) {
	    return h & (length-1);
	}

//hash表的扩容操作：
void addEntry(int hash, K key, V value, int bucketIndex) {
	
	    //当size超过临界阈值threshold，并且即将发生哈希冲突时进行扩容       
	     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);
	    }

当发生哈希冲突并且size大于阈值的时候，需要进行数组扩容，扩容时，需要新建一个长度为之前数组2倍的新的数组，然后将当前的Entry数组中的元素全部传输过去，扩容后的新数组长度为之前的2倍，所以扩容相对来说是个耗资源的操作。

###2.4.2、get（）：

public V get(Object key) {
	
	       //如果key为null,则直接去table[0]处去检索即可。
	        if (key == null)
	            return getForNullKey();
	        Entry<K,V> entry = getEntry(key);
	        return null == entry ? null : entry.getValue();
	}
	final Entry<K,V> getEntry(Object key) {
	            
	        if (size == 0) {
	            return null;
	        }
	
	        //通过key的hashcode值计算hash值
	        int hash = (key == null) ? 0 : hash(key);
	
	        //indexFor (hash&length-1) 获取最终数组索引，然后遍历链表，通过equals方法比对找出对应记录
	        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;
	    }

get方法的实现相对简单，key(hashcode)-->hash()计算hash值-->indexFor计算最终索引位置，找到对应位置table[i]，再查看是否有链表，遍历链表。

遍历链表：
        • 先比较key的hash值是否一致
        • 再比较key的内存地址是否一致。 key == k.key
        • 最后比较key的值是否一致。 key.equals（k）

###2.4.3、扩容原理：
//todo 有空来填坑

##2.5、注意点：

重写equals方法需同时重写hashCode方法。
在重写equals的方法的时候，必须注意重写hashCode方法，同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值,有相同的哈希表下表值。而如果equals判断不相等的两个对象，其hashCode可以相同（只不过会发生哈希冲突，应尽量避免）。
因为：如果传入的key对象Person类重写了equals方法却没有重写hashCode，此时Person类的2个对象person1 person2：如果仅仅用equals判断可能是相等的person1.equals(person2)返回true，但是person1 的hashCode和person2 的hashCode不一致，这种情况HashMap的get()方法返回为null。

public class MyTest {
	    private static class Person{
	        int idCard;
	        String name;
	
	        public Person(int idCard, String name) {
	            this.idCard = idCard;
	            this.name = name;
	        }
	        @Override
	        public boolean equals(Object o) {
	            if (this == o) {
	                return true;
	            }
	            if (o == null || getClass() != o.getClass()){
	                return false;
	            }
	            Person person = (Person) o;
	            //两个对象是否等值，通过idCard来确定
	            return this.idCard == person.idCard;
	        }
	
	    }
	    public static void main(String []args){
	        HashMap<Person,String> map = new HashMap<Person, String>();
	        Person person = new Person(1234,"乔峰");
	        //put到hashmap中去
	        map.put(person,"天龙八部");
	        //get取出，从逻辑上讲应该能输出“天龙八部”

	        System.out.println("结果:"+map.get(new Person(1234,"萧峰")));  //实际返回null结果。
	    }
	}

参考文章：https://www.cnblogs.com/chengxiao/p/6059914.html