面试必会之HashMap源码分析

相关文章

面试必会之ArrayList源码分析

面试必会之LinkedList源码分析

简介

HashMap最早出现在JDK1.2中，底层基于散列算法实现。HashMap 允许 null 键和 null 值，是非线程安全类，在多线程环境下可能会存在问题。

1.8版本的HashMap数据结构：

为什么有的是链表有的是红黑树？

默认链表长度大于8时转为树

结构

Node是HhaspMap中的一个静态内部类 ：

 1 //Node是单向链表，实现了Map.Entry接口
 2 static class Node<K,V> implements Map.Entry<K,V> {
 3     final int hash;
 4     final K key;
 5     V value;
 6     Node<K,V> next;
 7     //构造函数
 8     Node(int hash, K key, V value, Node<K,V> next) {
 9         this.hash = hash;
10         this.key = key;
11         this.value = value;
12         this.next = next;
13     }
14
15     // getter and setter ... toString ...
16     public final K getKey()        { return key; }
17     public final V getValue()      { return value; }
18     public final String toString() { return key + "=" + value; }
19
20     public final int hashCode() {
21         return Objects.hashCode(key) ^ Objects.hashCode(value);
22     }
23
24     public final V setValue(V newValue) {
25         V oldValue = value;
26         value = newValue;
27         return oldValue;
28     }
29
30     public final boolean equals(Object o) {
31         if (o == this)
32             return true;
33         if (o instanceof Map.Entry) {
34             Map.Entry<?,?> e = (Map.Entry<?,?>)o;
35             if (Objects.equals(key, e.getKey()) &&
36                 Objects.equals(value, e.getValue()))
37                 return true;
38         }
39         return false;
40     }
41 }

TreeNode 是红黑树的数据结构。

 1 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
 2     TreeNode<K,V> parent;  // red-black tree links
 3     TreeNode<K,V> left;
 4     TreeNode<K,V> right;
 5     TreeNode<K,V> prev;    // needed to unlink next upon deletion
 6     boolean red;
 7     TreeNode(int hash, K key, V val, Node<K,V> next) {
 8         super(hash, key, val, next);
 9     }
10
11     /**
12      * Returns root of tree containing this node.
13      */
14     final TreeNode<K,V> root() {
15         for (TreeNode<K,V> r = this, p;;) {
16             if ((p = r.parent) == null)
17                 return r;
18             r = p;
19         }
20     }

类定义

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

变量

 1 /**
 2  * 默认初始容量16(必须是2的幂次方)
 3  */
 4 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
 5
 6 /**
 7  * 最大容量，2的30次方
 8  */
 9 static final int MAXIMUM_CAPACITY = 1 << 30;
10
11 /**
12  * 默认加载因子，用来计算threshold
13  */
14 static final float DEFAULT_LOAD_FACTOR = 0.75f;
15
16 /**
17  * 链表转成树的阈值，当桶中链表长度大于8时转成树
18    threshold = capacity * loadFactor
19  */
20 static final int TREEIFY_THRESHOLD = 8;
21
22 /**
23  * 进行resize操作时，若桶中数量少于6则从树转成链表
24  */
25 static final int UNTREEIFY_THRESHOLD = 6;
26
27 /**
28  * 桶中结构转化为红黑树对应的table的最小大小
29
30  当需要将解决 hash 冲突的链表转变为红黑树时，
31  需要判断下此时数组容量，
32  若是由于数组容量太小（小于　MIN_TREEIFY_CAPACITY　）
33  导致的 hash 冲突太多，则不进行链表转变为红黑树操作，
34  转为利用　resize() 函数对　hashMap 扩容
35  */
36 static final int MIN_TREEIFY_CAPACITY = 64;
37 /**
38  保存Node<K,V>节点的数组
39  该表在首次使用时初始化，并根据需要调整大小。 分配时，
40  长度始终是2的幂。
41  */
42 transient Node<K,V>[] table;
43
44 /**
45  * 存放具体元素的集
46  */
47 transient Set<Map.Entry<K,V>> entrySet;
48
49 /**
50  * 记录 hashMap 当前存储的元素的数量
51  */
52 transient int size;
53
54 /**
55  * 每次更改map结构的计数器
56  */
57 transient int modCount;
58
59 /**
60  * 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
61  */
62 int threshold;
63
64 /**
65  * 负载因子：要调整大小的下一个大小值（容量*加载因子）。
66  */
67 final float loadFactor;

构造方法

 1 /**
 2  * 传入初始容量大小，使用默认负载因子值 来初始化HashMap对象
 3  */
 4 public HashMap(int initialCapacity) {
 5     this(initialCapacity, DEFAULT_LOAD_FACTOR);
 6 }
 7
 8 /**
 9  * 默认容量和负载因子
10  */
11 public HashMap() {
12     this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
13 }
14 /**
15  * 传入初始容量大小和负载因子 来初始化HashMap对象
16  */
17 public HashMap(int initialCapacity, float loadFactor) {
18     // 初始容量不能小于0，否则报错
19     if (initialCapacity < 0)
20         throw new IllegalArgumentException("Illegal initial capacity: " +
21                                            initialCapacity);
22     // 初始容量不能大于最大值，否则为最大值
23     if (initialCapacity > MAXIMUM_CAPACITY)
24         initialCapacity = MAXIMUM_CAPACITY;
25     //负载因子不能小于或等于0，不能为非数字
26     if (loadFactor <= 0 || Float.isNaN(loadFactor))
27         throw new IllegalArgumentException("Illegal load factor: " +
28                                            loadFactor);
29     // 初始化负载因子
30     this.loadFactor = loadFactor;
31     // 初始化threshold大小
32     this.threshold = tableSizeFor(initialCapacity);
33 }
34
35 /**
36  * 找到大于或等于 cap 的最小2的整数次幂的数。
37  */
38 static final int tableSizeFor(int cap) {
39     int n = cap - 1;
40     n |= n >>> 1;
41     n |= n >>> 2;
42     n |= n >>> 4;
43     n |= n >>> 8;
44     n |= n >>> 16;
45     return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
46 }
tableSizeFor方法详解：

用位运算找到大于或等于 cap 的最小2的整数次幂的数。比如10，则返回16

  1. 让cap-1再赋值给n的目的是使得找到的目标值大于或等于原值。例如二进制0100,十进制是4,若不减1而直接操作，答案是0001 0000十进制是16，明显不符合预期。
  2. 对n右移1位：001xx…xxx，再位或：011xx…xxx
  3. 对n右移2位：00011…xxx，再位或：01111…xxx
  4. 对n右移4位…
  5. 对n右移8位…
  6. 对n右移16位,因为int最大就2^32所以移动1、2、4、8、16位并取位或,会将最高位的1后面的位全变为1。
  7. 再让结果n+1，即得到了2的整数次幂的值了。

附带一个实例：

loadFactor 负载因子

对于 HashMap 来说，负载因子是一个很重要的参数，该参数反应了 HashMap 桶数组的使用情况。通过调节负载因子，可使 HashMap 时间和空间复杂度上有不同的表现。

当我们调低负载因子时，HashMap 所能容纳的键值对数量变少。扩容时，重新将键值对存储新的桶数组里，键的键之间产生的碰撞会下降，链表长度变短。此时，HashMap 的增删改查等操作的效率将会变高，这里是典型的拿空间换时间。

相反，如果增加负载因子（负载因子可以大于1），HashMap 所能容纳的键值对数量变多，空间利用率高，但碰撞率也高。这意味着链表长度变长，效率也随之降低，这种情况是拿时间换空间。至于负载因子怎么调节，这个看使用场景了。

一般情况下，我们用默认值就可以了。大多数情况下0.75在时间跟空间代价上达到了平衡所以不建议修改。

查找

 1 public V get(Object key) {
 2     Node<K,V> e;
 3     return (e = getNode(hash(key), key)) == null ? null : e.value;
 4 }
 5 // 获取hash值
 6 static final int hash(Object key) {
 7     int h;
 8     // 拿到key的hash值后与其五符号右移16位取与
 9     // 通过这种方式，让高位数据与低位数据进行异或，以此加大低位信息的随机性，变相的让高位数据参与到计算中。
10     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
11 }
12
13 final Node<K,V> getNode(int hash, Object key) {
14     Node<K,V>[] tab;
15     Node<K,V> first, e;
16     int n; K k;
17     // 定位键值对所在桶的位置
18     if ((tab = table) != null && (n = tab.length) > 0 &&
19         (first = tab[(n - 1) & hash]) != null) {
20         // 判断桶中第一项(数组元素)相等
21         if (first.hash == hash && // always check first node
22             ((k = first.key) == key || (key != null && key.equals(k))))
23             return first;
24         // 桶中不止一个结点
25         if ((e = first.next) != null) {
26             // 是否是红黑树，是的话调用getTreeNode方法
27             if (first instanceof TreeNode)
28                 return ((TreeNode<K,V>)first).getTreeNode(hash, key);
29             // 不是红黑树的话，在链表中遍历查找
30             do {
31                 if (e.hash == hash &&
32                     ((k = e.key) == key || (key != null && key.equals(k))))
33                     return e;
34             } while ((e = e.next) != null);
35         }
36     }
37     return null;
38 }

注意：

  1. HashMap的hash算法(hash()方法)。
  2. (n - 1) &amp; hash等价于对 length 取余。

添加

 1 public V put(K key, V value) {
 2     // 调用hash(key)方法来计算hash
 3     return putVal(hash(key), key, value, false, true);
 4 }
 5
 6 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 7                boolean evict) {
 8     Node<K,V>[] tab;
 9     Node<K,V> p;
10     int n, i;
11     // 容量初始化：当table为空，则调用resize()方法来初始化容器
12     if ((tab = table) == null || (n = tab.length) == 0)
13         n = (tab = resize()).length;
14     //确定元素存放在哪个桶中，桶为空，新生成结点放入桶中
15     if ((p = tab[i = (n - 1) & hash]) == null)
16         tab[i] = newNode(hash, key, value, null);
17     else {
18         Node<K,V> e; K k;
19         // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
20         if (p.hash == hash &&
21             ((k = p.key) == key || (key != null && key.equals(k))))
22             //如果键的值以及节点 hash 等于链表中的第一个键值对节点时，则将 e 指向该键值对
23             e = p;
24         // 如果桶中的引用类型为 TreeNode，则调用红黑树的插入方法
25         else if (p instanceof TreeNode)
26             // 放入树中
27             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
28         else {
29             //对链表进行遍历，并统计链表长度
30             for (int binCount = 0; ; ++binCount) {
31                 // 到达链表的尾部
32                 if ((e = p.next) == null) {
33                     //在尾部插入新结点
34                     p.next = newNode(hash, key, value, null);
35                     // 如果结点数量达到阈值，转化为红黑树
36                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
37                         treeifyBin(tab, hash);
38                     break;
39                 }
40                 // 判断链表中结点的key值与插入的元素的key值是否相等
41                 if (e.hash == hash &&
42                     ((k = e.key) == key || (key != null && key.equals(k))))
43                     break;
44                 p = e;
45             }
46         }
47         //判断要插入的键值对是否存在 HashMap 中
48         if (e != null) { // existing mapping for key
49             V oldValue = e.value;
50             // onlyIfAbsent 表示是否仅在 oldValue 为 null 的情况下更新键值对的值
51             if (!onlyIfAbsent || oldValue == null)
52                 e.value = value;
53             afterNodeAccess(e);
54             return oldValue;
55         }
56     }
57     ++modCount;
58     // 键值对数量超过阈值时，则进行扩容
59     if (++size > threshold)
60         resize();
61     afterNodeInsertion(evict);
62     return null;
63 }

事实上，new HashMap();完成后，如果没有put操作，是不会分配存储空间的。

  1. 当桶数组 table 为空时，通过扩容的方式初始化 table
  2. 查找要插入的键值对是否已经存在，存在的话根据条件判断是否用新值替换旧值
  3. 如果不存在，则将键值对链入链表中，并根据链表长度决定是否将链表转为红黑树
  4. 判断键值对数量是否大于阈值，大于的话则进行扩容操作

扩容机制

在 HashMap 中，桶数组的长度均是2的幂，阈值大小为桶数组长度与负载因子的乘积。当 HashMap 中的键值对数量超过阈值时，进行扩容。

HashMap 按当前桶数组长度的2倍进行扩容，阈值也变为原来的2倍（如果计算过程中，阈值溢出归零，则按阈值公式重新计算）。扩容之后，要重新计算键值对的位置，并把它们移动到合适的位置上去。

 1 final Node<K,V>[] resize() {
 2     // 拿到数组桶
 3     Node<K,V>[] oldTab = table;
 4     int oldCap = (oldTab == null) ? 0 : oldTab.length;
 5     int oldThr = threshold;
 6     int newCap, newThr = 0;
 7     // 如果数组桶的容量大与0
 8     if (oldCap > 0) {
 9         // 如果比最大值还大，则赋值为最大值
10         if (oldCap >= MAXIMUM_CAPACITY) {
11             threshold = Integer.MAX_VALUE;
12             return oldTab;
13         }
14         // 如果扩容后小于最大值 而且 旧数组桶大于初始容量16， 阈值左移1(扩大2倍)
15         else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
16                  oldCap >= DEFAULT_INITIAL_CAPACITY)
17             newThr = oldThr << 1; // double threshold
18     }
19     // 如果数组桶容量<=0 且 旧阈值 >0
20     else if (oldThr > 0) // initial capacity was placed in threshold
21         // 新容量=旧阈值
22         newCap = oldThr;
23     // 如果数组桶容量<=0 且 旧阈值 <=0
24     else {               // zero initial threshold signifies using defaults
25         // 新容量=默认容量
26         newCap = DEFAULT_INITIAL_CAPACITY;
27         // 新阈值= 负载因子*默认容量
28         newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
29     }
30     // 如果新阈值为0
31     if (newThr == 0) {
32         // 重新计算阈值
33         float ft = (float)newCap * loadFactor;
34         newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
35                   (int)ft : Integer.MAX_VALUE);
36     }
37     // 更新阈值
38     threshold = newThr;
39     @SuppressWarnings({"rawtypes","unchecked"})
40         // 创建新数组
41         Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
42     // 覆盖数组桶
43     table = newTab;
44     // 如果旧数组桶不是空，则遍历桶数组，并将键值对映射到新的桶数组中
45     if (oldTab != null) {
46         for (int j = 0; j < oldCap; ++j) {
47             Node<K,V> e;
48             if ((e = oldTab[j]) != null) {
49                 oldTab[j] = null;
50                 if (e.next == null)
51                     newTab[e.hash & (newCap - 1)] = e;
52                 // 如果是红黑树
53                 else if (e instanceof TreeNode)
54                     // 重新映射时，需要对红黑树进行拆分
55                     ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
56                 else { // preserve order
57                     // 如果不是红黑树，则按链表处理
58                     Node<K,V> loHead = null, loTail = null;
59                     Node<K,V> hiHead = null, hiTail = null;
60                     Node<K,V> next;
61                     // 遍历链表，并将链表节点按原顺序进行分组
62                     do {
63                         next = e.next;
64                         if ((e.hash & oldCap) == 0) {
65                             if (loTail == null)
66                                 loHead = e;
67                             else
68                                 loTail.next = e;
69                             loTail = e;
70                         }
71                         else {
72                             if (hiTail == null)
73                                 hiHead = e;
74                             else
75                                 hiTail.next = e;
76                             hiTail = e;
77                         }
78                     } while ((e = next) != null);
79                     // 将分组后的链表映射到新桶中
80                     if (loTail != null) {
81                         loTail.next = null;
82                         newTab[j] = loHead;
83                     }
84                     if (hiTail != null) {
85                         hiTail.next = null;
86                         newTab[j + oldCap] = hiHead;
87                     }
88                 }
89             }
90         }
91     }
92     return newTab;
93 }

整体步骤：

  1. 计算新桶数组的容量 newCap 和新阈值 newThr
  2. 根据计算出的 newCap 创建新的桶数组，桶数组 table 也是在这里进行初始化的
  3. 将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型，则需要拆分红黑树。如果是普通节点，则节点按原顺序进行分组。

总结起来，一共有三种扩容方式：

  1. 使用默认构造方法初始化HashMap。从前文可以知道HashMap在一开始初始化的时候会返回一个空的table，并且thershold为0。因此第一次扩容的容量为默认值DEFAULT_INITIAL_CAPACITY也就是16。同时threshold = DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR = 12。
  2. 指定初始容量的构造方法初始化HashMap。那么从下面源码可以看到初始容量会等于threshold，接着threshold = 当前的容量（threshold） * DEFAULT_LOAD_FACTOR。
  3. HashMap不是第一次扩容。如果HashMap已经扩容过的话，那么每次table的容量以及threshold量为原有的两倍。

细心点的人会很好奇，为什么要判断loadFactor为0呢？

loadFactor小数位为 0，整数位可被2整除且大于等于8时，在某次计算中就可能会导致 newThr 溢出归零。

疑问和进阶

1. JDK1.7是基于数组+单链表实现（为什么不用双链表）

首先，用链表是为了解决hash冲突。

单链表能实现为什么要用双链表呢?(双链表需要更大的存储空间)

2. 为什么要用红黑树，而不用平衡二叉树？

插入效率比平衡二叉树高，查询效率比普通二叉树高。所以选择性能相对折中的红黑树。

3. 重写对象的Equals方法时，要重写hashCode方法，为什么？跟HashMap有什么关系？

equals与hashcode间的关系:

  1. 如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；
  2. 如果两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)

因为在 HashMap 的链表结构中遍历判断的时候，特定情况下重写的 equals 方法比较对象是否相等的业务逻辑比较复杂，循环下来更是影响查找效率。所以这里把 hashcode 的判断放在前面，只要 hashcode 不相等就玩儿完，不用再去调用复杂的 equals 了。很多程度地提升 HashMap 的使用效率。

所以重写 hashcode 方法是为了让我们能够正常使用 HashMap 等集合类，因为 HashMap 判断对象是否相等既要比较 hashcode 又要使用 equals 比较。而这样的实现是为了提高 HashMap 的效率。

附上源码图：

4. HashMap为什么不直接使用对象的原始hash值呢?

1 static final int hash(Object key) {
2     int h;
3     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
4 }

我们发现，HashMap的哈希值是通过上面的方式获取，而不是通过key.hashCode()方法获取。

原因：

通过移位和异或运算，可以让 hash 变得更复杂，进而影响 hash 的分布性。

5. 既然红黑树那么好，为啥hashmap不直接采用红黑树，而是当大于8个的时候才转换红黑树？

因为红黑树需要进行左旋，右旋操作， 而单链表不需要。

以下都是单链表与红黑树结构对比。

如果元素小于8个，查询成本高，新增成本低。

如果元素大于8个，查询成本低，新增成本高。

至于为什么选数字8，是大佬折中衡量的结果-.-，就像loadFactor默认值0.75一样。

原文地址：https://www.cnblogs.com/javazhiyin/p/10475302.html

时间： 2024-11-05 17:32:25

面试必会之HashMap源码分析的相关文章

Java BAT大型公司面试必考技能视频-1.HashMap源码分析与实现

视频通过以下四个方面介绍了HASHMAP的内容 一. 什么是HashMap Hash散列将一个任意的长度通过某种算法(Hash函数算法)转换成一个固定的值. MAP:地图 x,y 存储 总结:通过HASH出来的值,然后通过值定位到这个MAP,然后value存储到这个MAP中的HASHMAP基本原理 1. KEY 是否可以为空?可以,Null当成一个Key来存储 2. 如果Hash KEY重复了会覆盖吗?会覆盖,但返回旧的值 3. HASHMAP什么时候做扩容?put 的时候,阀值高于或等于0.7

[Java] HashMap源码分析

1.概述 Hashmap继承于AbstractMap,实现了Map.Cloneable.java.io.Serializable接口.它的key.value都可以为null,映射不是有序的. Hashmap不是同步的,如果想要线程安全的HashMap,可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap. Map map = Collections.synchronizedMap(new HashMap()); (除了不同步和允许使用 null 之

【JAVA集合】HashMap源码分析（转载）

原文出处:http://www.cnblogs.com/chenpi/p/5280304.html 以下内容基于jdk1.7.0_79源码: 什么是HashMap 基于哈希表的一个Map接口实现,存储的对象是一个键值对对象(Entry<K,V>): HashMap补充说明 基于数组和链表实现,内部维护着一个数组table,该数组保存着每个链表的表头结点:查找时,先通过hash函数计算hash值,再根据hash值计算数组索引,然后根据索引找到链表表头结点,然后遍历查找该链表: HashMap数据

HashMap源码分析(转载)

一.HashMap概述 HashMap基于哈希表的 Map 接口的实现.此实现提供所有可选的映射操作,并允许使用 null 值和 null 键.(除了不同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同.)此类不保证映射的顺序,特别是它不保证该顺序恒久不变. 值得注意的是HashMap不是线程安全的,如果想要线程安全的HashMap,可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap. Map map = Coll

Java集合系列之HashMap源码分析

一.HashMap简介 HashMap是基于哈希表的Map接口实现的,它存储的是内容是键值对<key,value>映射.此类不保证映射的顺序,假定哈希函数将元素适当的分布在各桶之间,可为基本操作(get和put)提供稳定的性能. ps:本文中的源码来自jdk1.8.0_45/src. 1.重要参数 HashMap的实例有两个参数影响其性能. 初始容量:哈希表中桶的数量 加载因子:哈希表在其容量自动增加之前可以达到多满的一种尺度 当哈希表中条目数超出了当前容量*加载因子(其实就是HashMap的

Java集合之HashMap源码分析

一.HashMap简介 HashMap是基于哈希表的Map接口实现的,它存储的是内容是键值对<key,value>映射.此类不保证映射的顺序,假定哈希函数将元素适当的分布在各桶之间,可为基本操作(get和put)提供稳定的性能. ps:本文中的源码来自jdk1.8.0_45/src. 1.重要参数 HashMap的实例有两个参数影响其性能. 初始容量:哈希表中桶的数量 加载因子:哈希表在其容量自动增加之前可以达到多满的一种尺度 当哈希表中条目数超出了当前容量*加载因子(其实就是HashMap的

Java中HashMap源码分析

一.HashMap概述 HashMap基于哈希表的Map接口的实现.此实现提供所有可选的映射操作,并允许使用null值和null键.(除了不同步和允许使用null之外,HashMap类与Hashtable大致相同)此类不保证映射的顺序,特别是它不保证该顺序恒久不变. 值得注意的是HashMap不是线程安全的,如果想要线程安全的HashMap,可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap. Map map = Collections.sync

Java进阶之----HashMap源码分析

今天我们接着来看HashMap的源码,对几个常用的方法进行分析.在分析之前,我们还是要先对HashMap的结构有一个了解.看过之前我分析的ArrayList和LinkedList源码的朋友应该清楚,ArrayList内部是以数组实现的,LinkedList内部是以链表实现的.而HashMap则是对数组和链表的结合,虽然看上去复杂了一些,不过仔细分析一下,还是很好理解的.我们来看一张图片,是我根据我的理解画的. 我们在来看看Entry的内部结构是什么: 以上两个图,相信大家对HashMap的结构有

HashMap源码分析--jdk1.8

JDK1.8 ArrayList源码分析--jdk1.8LinkedList源码分析--jdk1.8HashMap源码分析--jdk1.8 HashMap概述 ??1. HashMap是可以动态扩容的数组,基于数组.链表.红黑树实现的集合.??2. HashMap支持键值对取值.克隆.序列化,元素无序,key不可重复value可重复,都可为null.??3. HashMap初始默认长度16,超出扩容2倍,填充因子0.75f.??4.HashMap当链表的长度大于8的且数组大小大于64时,链表结构