Java中HashMap源码解析

最新推荐文章于 2022-08-27 02:02:52 发布
最新推荐文章于 2022-08-27 02:02:52 发布
阅读量824 收藏
点赞数
分类专栏： Java容器解析 文章标签： hashmap 源码 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hp910315/article/details/48660867
版权

首先来看看构造函数

transient HashMapEntry<K, V>[] table;

public HashMap() {
    table = (HashMapEntry<K, V>[]) EMPTY_TABLE;
    threshold = -1; // Forces first put invocation to replace EMPTY_TABLE
}

private static final Entry[] EMPTY_TABLE
        = new HashMapEntry[MINIMUM_CAPACITY >>> 1];

private static final int MINIMUM_CAPACITY = 4;

从上面可以看到创建了一个大小为2的HashMapEntry数组。HashMapEntry是一个链表实体，它里面有四个成员变量。

再来看看它的另外一个构造函数：

public HashMap(int capacity) {
    if (capacity < 0) {
        throw new IllegalArgumentException("Capacity: " + capacity);
    }
    //
    if (capacity == 0) {
        @SuppressWarnings("unchecked")
        HashMapEntry<K, V>[] tab = (HashMapEntry<K, V>[]) EMPTY_TABLE;
        table = tab;
        threshold = -1; // Forces first put() to replace EMPTY_TABLE
        return;
    }

    if (capacity < MINIMUM_CAPACITY) {
        capacity = MINIMUM_CAPACITY;
    } else if (capacity > MAXIMUM_CAPACITY) {
        capacity = MAXIMUM_CAPACITY;
    } else {
        capacity = Collections.roundUpToPowerOfTwo(capacity);
    }
    makeTable(capacity);
}

这个构造函数可以指定HashMapEntry数组的大小。当capacity == 0时，跟第一个构造函数相同。我们来看看capacity>0的情况.
1、当capacity < MINIMUM_CAPACITY时，就让capacity = MINIMUM_CAPACITY，也就是说数组大小最小为MINIMUM_CAPACITY。
2、当capacity > MAXIMUM_CAPACITY时，就让capacity = MAXIMUM_CAPACITY，也就是说数组大小最大为MAXIMUM_CAPACITY。

private static final int MINIMUM_CAPACITY = 4;

private static final int MAXIMUM_CAPACITY = 1 << 30;

3、当 MINIMUM_CAPACITY < capacity < MAXIMUM_CAPACITY 时，执行Collections.roundUpToPowerOfTwo(capacity)，这个函数的作用是得到让capacity转换成2的(capacity-1的二进制位数)次方。也就是说如果capacity为5，它的二进制为101，减1后为100，位数为3，即最终得到的capacity为2的3次方。

具体的实现如下：

public static int roundUpToPowerOfTwo(int i) {
    i--; // If input is a power of two, shift its high-order bit right.

    // "Smear" the high-order bit all the way to the right.
    i |= i >>>  1;
    i |= i >>>  2;
    i |= i >>>  4;
    i |= i >>>  8;
    i |= i >>> 16;

    return i + 1;
}

上面的过程可以动笔来算算。

最后执行makeTable(capacity)函数，来看看具体的实现。

private HashMapEntry<K, V>[] makeTable(int newCapacity) {
    @SuppressWarnings("unchecked") HashMapEntry<K, V>[] newTable
            = (HashMapEntry<K, V>[]) new HashMapEntry[newCapacity];
    table = newTable;
    threshold = (newCapacity >> 1) + (newCapacity >> 2); // 3/4 capacity
    return newTable;
}

它的操作就是创建了一个大小为newCapacity的HashMapEntry数组。阀值为3/4 capacity。
从上面的构造构成可以看到，当我们创建一个HashMap的时候，它内部都会创建一个HashMapEntry数组，如果是无参的构造函数，那么数组的大小为2，如果是有参，则数组的大小会根据参数的值来计算。从这里也可以看到为什么HashMap比ArrayMap的内存占用率高，因为当它们为空的时候，HashMap都会分配空间，但是ArrayMap不会分配空间，从下图也可以看出。

这里写图片描述

当整个HashMap初始化完毕之后，我们来看看操作函数。
一、put操作

@Override public V put(K key, V value) {
    if (key == null) {
        return putValueForNullKey(value);
    }

    int hash = secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    int index = hash & (tab.length - 1);
    for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
        if (e.hash == hash && key.equals(e.key)) {
            preModify(e);
            V oldValue = e.value;
            e.value = value;
            return oldValue;
        }
    }

    // No entry for (non-null) key is present; create one
    modCount++;
    if (size++ > threshold) {
        tab = doubleCapacity();
        index = hash & (tab.length - 1);
    }
    addNewEntry(key, value, hash, index);
    return null;
}

1、如果插入的值的key为null，就会执行putValueForNullKey函数，具体来看看这个函数。

private V putValueForNullKey(V value) {
    HashMapEntry<K, V> entry为null，后面就执行 = entryForNullKey;
    if (entry == null) {
        addNewEntryForNullKey(value);
        size++;
        modCount++;
        return null;
    } else {
        preModify(entry);
        V oldValue = entry.value;
        entry.value = value;
        return oldValue;
    }
}

刚开始的时候entryForNullKey==null，所以entry为null，后面就执行addNewEntryForNullKey(value);

void addNewEntryForNullKey(V value) {
    entryForNullKey = new HashMapEntry<K, V>(null, value, 0, null);
}

它就创建了一个HashMapEntry对象被entryForNullKey进行引用，如果下次进来，entryForNullKey不为空，这样就可以直接修改这个对象里面的value值就可以，也就是对value进行更新。

2、如果key不为null，我们把上面的执行代码放下来分析分析。

//得到key值对应的hash值
int hash = secondaryHash(key);
HashMapEntry<K, V>[] tab = table;
//计算出这个key对应的索引值
int index = hash & (tab.length - 1);
//通过index找到数组中对应的实体对象，然后遍历这个对象后面的链表，查找是否存在在对象
//如果找到，那就只需要对对应的value值进行更新
for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
    if (e.hash == hash && key.equals(e.key)) {
        preModify(e);
        V oldValue = e.value;
        e.value = value;
        return oldValue;
    }
}

//如果没有找到，那么就需要创建一个，然后插入进去
modCount++;
//threshold是一个阀值，如果当前size个数比这个阀值要大，就需要把数组的大小加倍
//加倍之后，就需要重新计算index索引值了
if (size++ > threshold) {
    tab = doubleCapacity();
    index = hash & (tab.length - 1);
}
//最后就会把对应的键值对插入到对应的index处
addNewEntry(key, value, hash, index);

整个添加过程是怎样的，我们也来进行分析分析，进入addNewEntry函数：

void addNewEntry(K key, V value, int hash, int index) {
    table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);
}

假如在index位置第一次添加一个实体，如图所示：
这里写图片描述

第二次在index位置添加一个实体，分为下面几步：

new HashMapEntry<K, V>(key, value, hash, table[index]);

1、在构造函数中会将table[index]赋值给next引用，这样next也会引用到上一个实体对象，效果如下图所示：
这里写图片描述

table[index] = new HashMapEntry<K, V>(key, value, hash, table[index])

2、把新创建的实体对象赋值给table[index]，这样table[index]引用到新创建的这个实体，效果如下图所示：
这里写图片描述

当进行了很多次插入操作之后，效果图如下所示：
这里写图片描述

二、get操作

public V get(Object key) {
    if (key == null) {
        HashMapEntry<K, V> e = entryForNullKey;
        return e == null ? null : e.value;
    }

    // Doug Lea's supplemental secondaryHash function (inlined).
    // Replace with Collections.secondaryHash when the VM is fast enough (http://b/8290590).
    int hash = key.hashCode();
    hash ^= (hash >>> 20) ^ (hash >>> 12);
    hash ^= (hash >>> 7) ^ (hash >>> 4);

    HashMapEntry<K, V>[] tab = table;
    for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
            e != null; e = e.next) {
        K eKey = e.key;
        if (eKey == key || (e.hash == hash && key.equals(eKey))) {
            return e.value;
        }
    }
    return null;
}

把上面的弄懂之后，这个get操作就比较好理解了。

从上面我们指定，对于键值key为null的实体，它被单独存放在entryForNullKey中，所以：
1、当key == null
直接就可以获取entryForNullKey中的value值。

2、当key != null
得到key的hash值，然后通过hash找到对应的索引index，这样就可以在数组中找到找到对应的链表表头，进行遍历查找，找到之后，返回它的value值就可以。

三、remove操作

@Override public V remove(Object key) {
    if (key == null) {
        return removeNullKey();
    }
    int hash = secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    int index = hash & (tab.length - 1);
    for (HashMapEntry<K, V> e = tab[index], prev = null;
            e != null; prev = e, e = e.next) {
        if (e.hash == hash && key.equals(e.key)) {
            if (prev == null) {
                tab[index] = e.next;
            } else {
                prev.next = e.next;
            }
            modCount++;
            size--;
            postRemove(e);
            return e.value;
        }
    }
    return null;
}

同样分两种情况：
1、key == null
这个时候它会执行removeNullKey，我们来看看这个函数：

private V removeNullKey() {
    HashMapEntry<K, V> e = entryForNullKey;
    if (e == null) {
        return null;
    }
    entryForNullKey = null;
    modCount++;
    size--;
    postRemove(e);
    return e.value;
}

很简单，它直接把entryForNullKey置位了null.

2、key != null
它执行的就是链表的删除操作。

四、遍历操作
首先我们给出一种遍历方式：

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

下面来从源码看看它的过程：
首先我们来看看map.entrySet();

public Set<Entry<K, V>> entrySet() {
    Set<Entry<K, V>> es = entrySet;
    return (es != null) ? es : (entrySet = new EntrySet());
}

如果entrySet存在，就直接返回这个对象，否则就创建一个EntrySet对象，它是HashMap里面的一个内部类。

我们来看看EntrySet的iterator函数：

public Iterator<V> iterator() {
    return newValueIterator();
}

Iterator<Entry<K, V>> newEntryIterator() { 
    return new EntryIterator(); 
}

它创建了一个EntryIterator对象。

private final class EntryIterator extends HashIterator
        implements Iterator<Entry<K, V>> {
    public Entry<K, V> next() { return nextEntry(); }
}

可以看到它里面只有一个next函数，我们现在来看看它的父类HashIterator的构造函数：

private abstract class HashIterator {
    int nextIndex;
    HashMapEntry<K, V> nextEntry = entryForNullKey;
    HashMapEntry<K, V> lastEntryReturned;
    int expectedModCount = modCount;

    //在这个构造函数里面得到数组里面的第一个非空的值
    HashIterator() {
        if (nextEntry == null) {
            HashMapEntry<K, V>[] tab = table;
            HashMapEntry<K, V> next = null;
            while (next == null && nextIndex < tab.length) {
                next = tab[nextIndex++];
            }
            nextEntry = next;
        }
    }
}

下面我们看看EntryIterator里面的next函数，它里面执行的是nextEntry函数：

HashMapEntry<K, V> nextEntry() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    if (nextEntry == null)
        throw new NoSuchElementException();
    // 一项一项的遍历链表，如果链表遍历完毕,next就为null，它就会去找下一个非空的数组项
    HashMapEntry<K, V> entryToReturn = nextEntry;
    HashMapEntry<K, V>[] tab = table;
    HashMapEntry<K, V> next = entryToReturn.next;
    while (next == null && nextIndex < tab.length) {
        next = tab[nextIndex++];
    }
    nextEntry = next;
    return lastEntryReturned = entryToReturn;
}

下面来看看hasNext函数：

public boolean hasNext() {
    return nextEntry != null;
}

这个很简单，就是看nextEntry是否为空。

DroidMind
关注
专栏目录
HashMap源码解读—Java8版本
梵高
01-07 3155
人有两次生命，一次是出生，一次是觉醒，希望我们可以在风华正茂时重获新生，而不是在垂暮之年幡然醒悟。
【原创】ConcurrencyHashMap源码分析思维导图
12-09
【原创】ConcurrencyHashMap源码分析思维导图 欢迎大家在下面评论
HashMap深入浅出(思维导图)
大帅哥的博客
10-17 376
HashMap是面试中最经常出现得问题之一，此思维导图结合了热点面试题与HashMap的重要知识点，如觉有误，敬请指教
java中的HashMap解析
crazychen的专栏
04-09 1269
这篇文章准备从源码的角度带大家分析一下java中的hashMap的原理，在了解源码之前，我们先根据自己的理解创建一个hashMap。 先说明一下创建的具体原理是这样的，所谓hashMap,必然是用hash方法来区分不同的key值。学过hash的都知道，我们解决hash冲突的一种方法就是使用散列和桶，首先确定所在的桶号，然后在桶里面逐个查找。其实我们也可以单纯使用数组实现map,使用散列是为了获得
hashmap示例_Java HashMap get（）方法与示例
cumt30111的博客
07-24 737
hashmap示例 HashMap类的get()方法 (HashMap Class get() method) get() method is available in java.util package. get()方法在java.util包中可用。 get() method is used to get the value element associated with the given...
Java语言：Map集合之HashMap的添加显示查询（针对自定义数据类型）
日出印象
09-07 764
目录 添加和显示功能 添加功能的优化 查询功能 添加和显示功能 因为HashMap对于自定义的数据类型和系统已经定义好的数据类型的操作是不一样的 所以这里分成两篇写，这里就不再赘述HashMap的一些概念什么的了 想要看HashSet的概念可以看上一篇文章 Java语言：Map集合之HashMap的添加显示查询（针对系统定义类型数据，比如String） 同样，这里也是以一个例题的形式对自定义数据如何在HashSet中的操作进行阐述 这里设置了一个商品类，通过对商品类的各种操作去理解
Java中的HashMap源码分析
Palpitate_fx的博客
03-27 968
目录 HashMap的继承体系 什么是Map 哈希表 存储结构 HashMap的属性 Node内部类 HashMap的构造方法 数组容量的计算 put( K key,V value)方法 HashMap的扩容机制 HashMap新的数组的填充 HashMap的get操作 HashMap 中的红黑树 散列冲突解决方式 HashMap的继承体系 1.HashMap实现了Serializable接口，可以被序列化 2.HashMap实现了Cloneable接口，可..
【JAVA基础】JDK8 HashMap 源码深度解析
秀强的专栏
08-27 411
而且当 key 是 Integer 时且小于等于 65535 时，(h = key.hashCode())^ (h >>> 16) 和 key 的值是相等的，所以此时 key 是有序递增的。当 key 大于 65535 以后，高 16 位就不全是 0 了，(h = key.hashCode())^ (h >>> 16) 的值就与 key 不相等了。n = 16 时，(h ^ (h >>> 16)) & (n-1) = 5， 即计算出来的下标是 5。JDK8：数组 + 链表 + 红黑树。...
Java源码解析HashMap简介
08-26
Java源码解析HashMap简介 HashMap是Java开发中最常用的集合之一，它基于hash表的实现，提供了map的所有可选操作，并且允许null值和一个null的key。HashMap的实现提供了常量级的性能，假设hash函数把元素们比较好的...
Java源码解析HashMap的tableSizeFor函数
08-26
在Java编程语言中，HashMap是一种常用的散列表数据结构，它提供了高效的插入、删除和查找操作。HashMap的容量（Capacity）是存储元素的槽位数量，它必须是2的幂，如16、32、64等。这是因为HashMap使用了开放寻址法或...
HashMap的四种遍历方法详情
weixin_42237651的博客
05-19 154
public static void main(String[] args) { Map<String, String> map = new HashMap<String, String>(); map.put(“1”, “value1”); map.put(“2”, “value2”); map.put(“3”, “value3”); //第一种：普遍使用，二次取值 System.out.println(“通过Map.keySet遍历key和value：”); for (Strin
Redis之数据结构HashMap详细使用
热门推荐
点滴记录，积流成河！
04-25 2万+
一般大家使用redis的string数据结构比较多，在想使用其他数据结构，但是感觉操作复杂的现象身边很普遍， 为简化大家操作redis hashmap，特整理此文，方便大家使用。 一、Redis数据结构hashmap，RedisDesktopManager使用如下： 二、 通过代码 Java端使用 增： Map<String, UserRankDto&gt...
集合类源码——HashMap，HashTable，HashSet和LinkedHashSet（1.8）
weixin_39420024的博客
04-20 309
1、HashMap节选public class HashMap&lt;K, V&gt; extends AbstractMap&lt;K, V&gt; implements Map&lt;K, V&gt;, Cloneable, Serializable { // 默认容量，new时为0，put()时调用putval()，putval()调用resize()table才不为null // 大...
HashMap中插入null key的过程分析
大树叶 技术专栏
06-27 697
在HashMap中添加key==null的Entry时会调用putForNullKey方法 下面是HashMap的put方法： [java] view plain copy public V put(K key, V value) {          if (table == EMPTY_TABLE) {              i
【转】HashMap源码解读
HeyLinK的专栏
05-14 335
1、HashMap的存储结构 2、HashMap的初始化 3、元素Hash值获取及通过hash值找到talbe下标索引 4、元素添加方法addEntry 5、HashMap扩容 6、老table重新hash成新table 7、key为null，存到哪去了 8、查找元素get(Object key) 9、根据key删除元素 1、HashMap的存储结构   在HashMap的Field中有：  ...
Java集合-HashMap源码实现深入解析
yangkang029的专栏
08-19 354
概述本文学习知识点 1.HashMap的存储结构怎么实现,它有什么特点。 2.HashMap的工作原理。 3.put和get方法实现源码分析。 4.hash值有什么作用？如何进行hash？equals和hashCode方法有什么作用? 5.何谓负载因子，有什么作用? 6.何时会触发扩容，以及如何扩容？ Map<String, String> map = ne
HashMap的底层工作原理和并发问题
AndroidConqueror的博客
09-19 2658
源码分析首先来看下HashMap一个典型的构造函数：transient HashMapEntry<K, V>[] table;public HashMap(int capacity) { if (capacity < 0) { throw new IllegalArgumentException("Capacity: " + capacity); } if (capac
Java HashMap源码解析与性能优化详解
在Java编程中，HashMap是一种常用的数据结构，它是基于哈希表实现的，提供了快速查找、插入和删除操作。本文将深入剖析HashMap的源码以及性能优化的关键点，主要针对Java 8及后续版本的HashMap。 HashMap的核心存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值