Java HashMap【底层实现，常用方法，遍历方式】详解

最新推荐文章于 2024-09-11 11:48:53 发布

GarethYoung

最新推荐文章于 2024-09-11 11:48:53 发布

阅读量413

点赞数

分类专栏： Java数据结构文章标签： hashmap java hash 哈希表

本文链接：https://blog.csdn.net/GarethYoung/article/details/118755434

版权

Java数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

HashMap是Java中重要的数据结构，底层实现为Entry数组加链表，采用哈希函数处理冲突。它通过put、get、remove等方法进行操作，并提供values和replace方法。当size达到阈值时，HashMap会进行扩容。遍历HashMap可通过for-each循环和迭代器。重写equals方法时，需同时重写hashCode，以确保逻辑等价的对象返回相同的哈希值。

摘要由CSDN通过智能技术生成

一、底层实现

1.Java键值对

Java键值对的实现方式为Entry数组。Entry是Map的一个内部接口，定义如下：

static class Entry<K,V> implements Map.Entry<K,V> 
{
        final K key;
        V value;
        Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
        int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) 
        {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

同时，在这里有getKey(),getValue()方法。

2.HashMap的底层实现方式

实现方式为数组，处理冲突的方式为链表。

数组的初始size为16。

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

3.Hash函数

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

4.HashMap存储Entry的步骤

hashCode()方法是Object类中的一个native方法，即此方法的具体实现与硬件平台即虚拟机有关，部分JVM中返还的是相应Entry 的地址。

indexFor()函数的作用是保证上一步得到的hash一定最终会落在相应数组的范围内。

static int indexFor(int h, int length) 
{
        return h & (length-1);
}

做完上面的步骤就已经能够得出数组储存的位置，接下来就是储存步骤。

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

扩容函数代码如下：

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

一个值得注意的点是如果发生了扩容，则需要将原来的已有的数据重新分配到新数组中的不同位置，这里运用到的方法是transfer()。

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

二、常用方法

1.构造函数

HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。

HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。

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

HashMap(Map<? extends K, ? extends V> m)：用一个map初始化哈希表。

负载因子含义：当size与当前最大量比值达到负载因子时扩容。

2.put、get、remove、values、replace

put(Object key,Object value);

putAll(Collection c);

代码示例：

hashMap0.putAll(hashMap1);

get(Object key)；

getOrDefault(Object key, V defaultValue)；

getOrDefault在key不存在时,返回一个defaultValue

此方法须在JDK1.8或更新的版本上使用

remove(Object key);

values()；

返还所有值的集合，返还Collection<Object>

replace(Object key,Object value);

replace与put的异同：

如果key存在，put与replace的功能都是更改相应的键值对

如果key不存在，put新增一个键值对，replace什么都不做

3.size、isEmpty、clear

size();

返还k-v的组数

isEmpty()；

clear();

清空哈希表

4.contains

containsKey(Object key)；

检测是否存在指定key的映射，有则返回true，没有则返回false

containsValue(Object value)；

检测是否存在指定value的映射，有则返回true；没有则返回false

三.遍历方式

1.for-each

for (Map.Entry<String, String> me:hm1.entrySet()) 
{
			System.out.println(me.getKey()+":"+me.getValue());
}

若只需要key或value，则将上述代码中entrySet()改为keySet()即可，而value可用values方法。

2.迭代器

Map map = new HashMap();
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) 
{
　	Map.Entry entry = (Map.Entry) iter.next();
　　Object key = entry.getKey();
　　Object val = entry.getValue();
}

四、重写equals方法需同时重写hashCode方法

尽管我们在进行get和put操作的时候，使用的key从逻辑上讲是等值的（通过equals比较是相等的），但由于没有重写hashCode方法，所以put操作时，key(hashcode1)–>hash–>indexFor–>最终索引位置，而通过key取出value的时候 key(hashcode1)–>hash–>indexFor–>最终索引位置，由于hashcode1不等于hashcode2，导致错误的发生。

所以，在重写equals的方法的时候，必须注意重写hashCode方法，同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值。而如果equals判断不相等的两个对象，其hashCode可以相同（只不过会发生哈希冲突，应尽量避免）。