HashMap在JDK1.8和JDK1.7的区别（详解）

HashMap在JDK1.8和JDK1.7的区别

结论

先说结论，HashMap在1.7和1.8中最大的区别就是底层数据结构的变化，在1.7中HashMap采用的底层数据结构是数组+链表的形式，而在1.8中HashMap采用的是数组+链表+红黑树的数据结构（当链表长度大于8且数组长度大于等于64时链表会转成红黑树，当长度低于6时红黑树又会转成链表），红黑树是一种平衡二叉搜索树，它能通过左旋、右旋、变色保持树的平衡，关于红黑树大家想了解的可以自行百度，这里不再讲述。之所以用红黑树是因为他能够大大提高查找效率，链表的时间复杂度是O(n)而红黑树的时间复杂度是O(logn)，那么为啥要链表长度大于8且数组长度大于64才转成红黑树呢，简单来说就是节点太少的时候没必要转换数据结构，因为不仅转换数据结构需要浪费时间同时也要浪费空间。而为什么不直接一直用红黑树呢？这是因为树的结构太浪费空间，只有节点足够多的情况下用树才能体现出它的优势，而如果在节点数量不够多的情况下用链表的效率更高，占用的空间更小。

HashMap是如何存放元素的呢

当我们向HashMap中存放数据时，首先会根据key的hashCode方法计算出值，然后结合数组长度和算法（如取余法、位运算等）来计算出向数组存放数据的位置索引值。如果索引位置不存在数据的话则将数据放到索引位中；如果索引位置已经存在数据，这时就发生了hash碰撞（两个不同的原始值在经过哈希运算后得到相同的结果），为了解决hash碰撞，JDK1.8前用的是数组+链表的形式，而JDK1.8后用的是数组+链表+红黑树，这里以链表为例。由于该位置的hash值和新元素的hash值相同，这时候要比较两个元素的内容如果内容相同则进行覆盖操作，如果内容不同则继续找链表中的下一个元素进行比较，以此类推如果都没重复的则在链表中新开辟一个空间存放元素。以上图为例，假设张三、王五、赵六、王五对应的数组数组下标是1，李四对应的数组下标是2。刚开始索引位置1为空，（张三，15）直接放入1位置，索引位置 2为空，（李四，22）直接放入2位置，（王五，18）发现索引位置1已经有数据，这时候调用equals方法和张三进行内容比较，发现内容不同，链表开辟新空间存放数据；（赵六，25）发现1位置已经有元素，调用equals和张三比较，内容不同，继续向下和王五比较，内容不同，开辟新空间存放数据；（王五，28）发现1位置已经有元素，调用equals和张三进行内容比较，不同，继续向下和（王五，18）比较，发现内容也相同，这时候则进行覆盖操作将原来的（王五，18）改成（王五，28）。

HashMap介绍

1.HashMap hashMap = new HashMap();

当创建一个HashMap集合对象的时候，在JDK8之前，构造方法中创建了一个长度是16的Entry[]table用来存储键值对数据。在JDK8后就不在HashMap的构造方法中创建数组了，而是在第一次调用put方法时创建数组Node[] table，用这个数组来存储键值对数据的。

初始容量大小介绍

说到数组就不得不提HashMap里面的成员变量DEFAULT_INITIAL_CAPACITY也就是容量大小，如果不指定的话默认是16，如果通过有参构造指定容器大小的话也必须是2的平方数，当然了如果传入的参数并不是2的平方数的话（最好不要这样，实在不知道写多少容量我们直接写个默认的大小16），HashMap会通过方法将它变成比这个数大且离2的平方数最近的数例如传入11他会变成16，之所以要这么做的原因是，根据上述讲解我们已经知道，当向 HashMap 中添加一个元素的时候，需要根据 key 的 hash 值，去确定其在数组中的具体位置。HashMap 为了存取高效，减少碰撞，就是要尽量把数据分配均匀，每个链表长度大致相同，这个实现的关键就在把数据存到哪个链表中的算法。这个算法实际就是取模，hash % length，计算机中直接求余效率不如位移运算。所以源码中做了优化，使用 hash & (length - 1)，而实际上 hash % length 等于 hash & ( length - 1) 的前提是 length 是 2 的 n 次幂。

上面提到了如果传入的指定大小并不是2的n次幂，HashMap会将大小变成比指定大小大且是2的n次幂的数，我们看看JDK1.7和JDK1.8是如何做的。

JDK1.7

   */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 >= initialCapacityint capacity = 1;// 从1开始不停的左移也就是变大2的n次幂，直到不比指定容量小// 1  2  4  8  16  32.。。。while (capacity < initialCapacity)capacity <<= 1;this.loadFactor = loadFactor;threshold = (int)(capacity * loadFactor);table = new Entry[capacity];init();}

JDK1.8

 // 假设cap为13static final int tableSizeFor(int cap) {// n=12 int类型在内存中占4个字节，，一个字节占8位int n = cap - 1;/** 00000000 00000000 00000000 00001100   12* 00000000 00000000 00000000 00000110   右移1位* ---------------------------------------------- 或运算* 00000000 00000000 00000000 00001110    14*/n |= n >>> 1; // n=14/** 00000000 00000000 00000000 00001110   12* 00000000 00000000 00000000 00000111   右移2位* ---------------------------------------------- 或运算* 00000000 00000000 00000000 00001111    15*/n |= n >>> 2;//计算完n=15/** 00000000 00000000 00000000 00001111   15* 00000000 00000000 00000000 00000000   右移4位* ---------------------------------------------- 或运算* 00000000 00000000 00000000 00001111    15*/n |= n >>> 4;// 计算完n=15/** 00000000 00000000 00000000 00001111   15* 00000000 00000000 00000000 00000000   右移8位* ---------------------------------------------- 或运算* 00000000 00000000 00000000 00001111    15*/n |= n >>> 8;// 计算完n=15/** 00000000 00000000 00000000 00001111   15* 00000000 00000000 00000000 00000000   右移16位* ---------------------------------------------- 或运算* 00000000 00000000 00000000 00001111    15*/n |= n >>> 16;// 计算完n=15return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;}

JDK1.8中的做法简单来说就是通过位运算将最高非0位后面全置为1，由上面可以看出通过这五次的计算，最后的结果刚好可以填满32位的空间，也就是一个int类型的空间，这就是为什么必须是int类型，且最多只无符号右移16位！那么为啥传进来的时候进行减1操作呢？因为当传入的参数刚好是2的n次幂时，算出来的结果是比传进来的值大的最小n次幂，比如恰好传进来16如果不减一的话最后计算出来的结果是64，和我们想要的结果不符合，因此在传进来的时候减一能够避免出现恰好是n次幂的情况导致结果不对。大家也可以手动算一算，这样就能明白了。

负载因子和阈值

负载因子static final float DEFAULT_LOAD_FACTOR = 0.75f和阈值int threshold的话是用来给map扩容判断时用的，负载因子也能够在构造函数中进行指定（不推荐），每次进行put的时候都会进行判断是否需要扩容，当size超过了阈值=总容量*负载因子，则会扩容，默认情况下总容量是16，负载因子是0.75，至于为啥是0.75这是由于经过大量的实验证明该系数是最合适的，如果设置过小，HashMap每put少量的数据，都要进行一次扩容，而扩容操作会消耗大量的性能。如果设置过大的话，如果设成1，容量还是16，假设现在数组上已经占用的15个，再要put数据进来，计算数组index时，发生hash碰撞的概率将达到15/16，这违背的HashMap减少hash碰撞的原则。

HashMap构造方法

JDK1.7中的无参构造方法：

 /*** Constructs an empty <tt>HashMap</tt> with the default initial capacity* (16) and the default load factor (0.75).*/public HashMap() {// 负载因子this.loadFactor = DEFAULT_LOAD_FACTOR;// 阈值：总容量*负载因子threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);// 存放键值对的entrytable = new Entry[DEFAULT_INITIAL_CAPACITY];init();}

JDK1.8中的构造方法：

public HashMap() {// 将负载因子设置为默认的0.75f，并没有在构造方法中创建Entry的数组，而是放到put方法中了this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted}

public HashMap(int initialCapacity, float loadFactor) {// 给的初始大小是不是小于0if (initialCapacity < 0)throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);// 是否超过最大容量，是的话则直接赋值最大容量if (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;// 给的加载因子是不是个大于0的数字if (loadFactor <= 0 || Float.isNaN(loadFactor))throw new IllegalArgumentException("Illegal load factor: " +loadFactor);// 设置加载因子的大小this.loadFactor = loadFactor;// 调整给定的数组大小this.threshold = tableSizeFor(initialCapacity);}

this.threshold = tableSizeFor(initialCapacity);判断指定的初始化容量是否是2的n次幂，如果不是那么会变为比指定初始化容量大的最小的2的n次幂。但是注意，在tableSizeFor方法体内部将计算后的数据返回给调用这里了，并且直接赋值给threshold边界值了。有些人会觉得这里是一个bug，应该这样书写：this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;这样才符合threshold的意思（当HashMap的size到达threshold这个阈值时会扩容）。但是请注意，在jdk8以后的构造方法中，并没有对table这个成员变量进行初始化，table的初始化被推迟到了put方法中，在put方法中会对threshold重新计算。

JDK1.8中的put方法

 public V put(K key, V value) {return putVal(hash(key), key, value, false, true);}final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {.......// 存放键值对的NodeNode<K,V>[] tab;.......}

在put方法中又调用了putVal(hash(key), key, value, false, true);以及hash(key)方法，首先我们先来看下hash(key)方法

static final int hash(Object key) {int h;// 如果key是null则hash值为0//(h = key.hashCode()) ^ (h >>> 16)// 先获取key的hashCode并赋值给h， 然后和h和h右移16位后做异或运算得到hash值return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}

这里有个步骤(h = key.hashCode()) ^ (h >>> 16)，为什么要获取完hashCode()赋值给h后要和h右移16位做异或运算呢，直接让h=key.hashCode()不行吗？实际上这是在进行put操作时尽可能的避免hash冲突，前面说过存放元素的时候寻找数组下标实际上是hash值对数组长度取余，当数组长度为2的n次幂时，(n - 1) & hash和hash%n是等价的而且运算效率比取余高，简单来说之所以这么做就是，高 16bit 不变，低 16bit 和高 16bit 做了一个异或（得到的 hashCode 转化为 32 位二进制，前 16 位和后 16 位低 16bit 和高 16bit 做了一个异或），可以看看下面计算，确实理解起来有点深度，但这也是人家牛逼之处。

假设：
数组大小n=16=0000 0000 0000 0000 0000 0000 0001 00001.假设hash直接和h相等
调用hashCode()方法h=h.hashCode()：
h=h.hashCode()=1111 1111 1111 1111 1111 0000 1110 1010
hash=1111 1111 1111 1111 1111 0000 1110 1010
计算数组下标：(n-1)&hash
(n-1):0000 0000 0000 0000 0000 0000 0000 1111
hash：1111 1111 1111 1111 1111 0000 1110 1010
---------------------------------------------
(n-1)&hash=0000 0000 0000 0000 0000 0000 0000 1010=10
我们看到真正参与运算的实际上只有最后四位，也就是说其他高位并没有参与运算
那么会出现一种状况，就是调用hashCode()方法获取的值高位不停的在变动但是
地位不变，这种状况就会造成(n-1)&hash结果会一致，造成hash冲突。2.假设hash = h^(h>>>16)：
调用hashCode()方法h=h.hashCode()：
h=h.hashCode()=1111 1111 1111 1111 1111 0000 1110 1010
(h>>>16):
0000 0000 0000 0000 1111 1111 1111 1111
hash = h^(h>>>16)：
1111 1111 1111 1111 0000 1111 0001 0101
计算数组下标：(n-1)&hash
(n-1):0000 0000 0000 0000 0000 0000 0000 1111
hash:1111 1111 1111 1111 0000 1111 0001 0101
------------------------------------------------
(n-1)&hash=0000 0000 0000 0000 0000 0000 0000 0101=5
简单来说就是通过右移16位和异或操作让高位地位都参与了运算尽可能的减少hash冲突

接着看putVal方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {/*Node<K,V>[] tab：存放元素的数组Node<K,V> p：用来保存索引位置的元素int n：n用来记录数组的长度int i：i用来记录索引的位置*/Node<K,V>[] tab; Node<K,V> p; int n, i;/*1.table：transient Node<K,V>[] table; 存放元素的数组2.(tab = table) == null 将table赋值给tab并判断是否为null   第一次put必然为null3.(n = tab.length) == 0  将数组的长度赋值给n并判断是否为0*/if ((tab = table) == null || (n = tab.length) == 0)// tab为null 或者 tab长度为0，进行扩容操作n = (tab = resize()).length;/*(n - 1) & hash：之前说过，当n为2的n次幂时这个操作等价于hash%n，即hash值对数组长度取余i = (n - 1) & hash：存放元素的数组索引下标索引位置不存在元素，则在索引位置创建一个新节点这里会给p进行赋值，不存元素p则为null*/if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);else {/* 执行else说明tab[i]不等于null，表示这个位置已经有值了Node<K,V> e：保存数据的节点K k：保存key*/Node<K,V> e; K k;/*1.p.hash == hash：p的hash值==传入的hash值2.(k = p.key) == key：将p的key赋值给k == 现在的key3.key != null && key.equals(k)))：key不为空&&key的内容和现在的key的内容相等同时满足1、2或者满足3，则将p节点赋值给e*/if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;/*判断p是否为红黑树结点*/else if (p instanceof TreeNode)/*往树中插入节点并赋值给e*/e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);else {/*binCount：记录遍历节点的个数*/for (int binCount = 0; ; ++binCount) {/*1)e = p.next 获取p的下一个元素赋值给e。2)(e = p.next) == null 判断p.next是否等于null，等于null，说明p没有下一个元素，那么此时到达了链表的尾部，还没有找到重复的key,则说明HashMap没有包含该键，将该键值对插入链表中。*/if ((e = p.next) == null) {/*最后一个节点了，所以next为nullJDK8采用尾插法新增节点，JDK8之前是头插法*/p.next = newNode(hash, key, value, null);/*判断是否要转成红黑树binCount是从0开始自增的，当binCount = 7时说明已经有8个节点加上刚刚插入的节点所以是9个，所以当链表长度>8时转成红黑树*/if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st// 转成红黑树treeifyBin(tab, hash);break;}/*执行到这里说明e = p.next 不是null，不是最后一个元素。继续判断链表中结点的key值与插入的元素的key值是否相等。*/if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))// 相等，跳出循环break;// 将e赋值给p，继续查找下一节点p = e;}}/*如果e!=null则说明通过上面的一系列操作，找到了重复的key，所以这里就是将key对应的原来的旧值替换成新值并将旧值返回*/if (e != null) { // existing mapping for key// 获取旧值V oldValue = e.value;// onlyIfAbsent为false或者oldValue为nullif (!onlyIfAbsent || oldValue == null)// 将新值保存e.value = value;// 访问后回调，点进去会发现是个空方法，是为了继承HashMap的LinkedHashMap类服务afterNodeAccess(e);// 返回旧值return oldValue;}}// 这个变量是用来记录修改次数的++modCount;// 判断新增元素后的大小是否比阈值大，如果是的话则要进行扩容操作if (++size > threshold)resize();// 插入后回调，点进去会发现是个空方法，是为了继承HashMap的LinkedHashMap类服务afterNodeInsertion(evict);return null;}

转成红黑树的__treeifyBin()__方法

 /*** 转成红黑树* @param tab* @param hash*/final void treeifyBin(Node<K,V>[] tab, int hash) {int n, index; Node<K,V> e;/*数组tab不为空或者数组长度小于64则进行扩容操作n = tab.length:数组长度赋值给n*/if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();/*转成红黑树操作e = tab[index = (n - 1) & hash])：获取索引位置元素*/else if ((e = tab[index = (n - 1) & hash]) != null) {/*hd：存放树的头结点tl：用来存放临时节点*/TreeNode<K,V> hd = null, tl = null;do {// 将链表节点转成树节点TreeNode<K,V> p = replacementTreeNode(e, null);/*tl：第一次临时节点必然为空将p节点赋值给头结点*/if (tl == null)hd = p;else {/*临时tl节点不为空：p.prev = tl：将tl赋值给p的prev节点tl.next = p：将p节点赋值给tl的next节点*/p.prev = tl;tl.next = p;}// 将p节点赋值给tl节点tl = p;} while ((e = e.next) != null); // 循环，直到Next节点不存在/*(tab[index] = hd)：将树的头结点赋值给数组索引位置*/if ((tab[index] = hd) != null)/*转成红黑树的具体操作*/hd.treeify(tab);}}

说明

size表示HashMap中键值对的实时数量，这个不等于数组的长度
threshold（临界值）= capacity（容量）* loadFactor（负载因子）。这个值是当前已占用数组长度的最大值。size 超过这个值就重新 resize（扩容），扩容后的 HashMap 容量是之前容量的两倍。

JDK1.7中的put方法

public V put(K key, V value) {/*如果Key是null的话，则调用putForNullKey方法putForNullKey：如果不存在null为key的Entry则新增，如果存在的话则替换原来的值并返回*/if (key == null)return putForNullKey(value);/*key.hashCode()：调用key的hashCode()获取hashCodehash(key.hashCode()):通过调用hash方法获得hash值这个操作实际上和JDK1.8的HashMap的hash(key)类似，也是通过该方法使得高低位都参与hash计算从而避免hash冲突，大家可以参考一下上面JDK1.8的HashMap*/int hash = hash(key.hashCode());/*这一步是计算出数组的索引下标计算方法和JDK8一样*/int i = indexFor(hash, table.length);/*Entry<K,V> e = table[i]：将索引下标对应的元素赋值给Entry这个步骤实际上就上遍历链表查找元素*/for (Entry<K,V> e = table[i]; e != null; e = e.next) {Object k;/*e的哈希值和新元素的hash值相等且内容也相同则说明key相同用新值替换节点中的旧值并将旧值返回*/if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}// 这个变量是用来记录修改次数的modCount++;// 到这一步说明没有key重复的元素，新增元素addEntry(hash, key, value, i);return null;}

新增元素的addEntry方法

void addEntry(int hash, K key, V value, int bucketIndex) {/*获取索引位置的Entry*/Entry<K,V> e = table[bucketIndex];/*采用头插法将元素插入到链表中新节点插入后将e赋值给next*/table[bucketIndex] = new Entry<>(hash, key, value, e);// 判断新增元素后数组大小是否超过阈值if (size++ >= threshold)// 扩容方法，将扩大为原来数组大小的两倍resize(2 * table.length);}

扩容方法resize()

HashMap在进行扩容时，每次扩容后的大小都是原来数组的两倍，然后将原数组中的元素分配到新的数组中去，那么它是如何分配的呢？由于每次进行扩容都是原来大小的两倍，计算table下标的方法是hash&(newTable.length-1)，也就是hash&(oldTable.length*2-1)，于是我们有了这样的结论：这新旧两次计算下标的结果，要不然就相同，要不然就是新下标等于旧下标加上旧数组的长度

旧数组长度：n=16
n：     0000 0000 0000 0000 0000 0000 0001 0000
n-1：   0000 0000 0000 0000 0000 0000 0000 1111
假设有两个元素的hash值为:
hash1： 1111 1111 1111 1111 0000 1111 0000 0101
hash2： 1111 1111 1111 1111 0000 1111 0001 0101
计算两个hash对应数组的索引位置:(n-1)*hash
index1: 0000 0000 0000 0000 0000 0000 0000 0101
index2: 0000 0000 0000 0000 0000 0000 0000 0101
在原数组中hash1和hash2通过计算对应的数组索引位置都是5(0101)================================================================
扩容后的新数组：n=2*n=32
n：     0000 0000 0000 0000 0000 0000 0010 0000
n-1：   0000 0000 0000 0000 0000 0000 0001 1111
元素还是之前的元素，也就是说hash还是之前的hash:
hash1： 1111 1111 1111 1111 0000 1111 0000 0101
hash2： 1111 1111 1111 1111 0000 1111 0001 0101
计算两个hash对应数组的索引位置:(n-1)*hash
index1: 0000 0000 0000 0000 0000 0000 0000 0101（5）
index2: 0000 0000 0000 0000 0000 0000 0001 0101（21）
从结果上看，在原数组中放到同一个索引位置的两个元素，在经过扩容重新
分配后，hash1计算出的索引位置还是原数组中的位置，hash2计算出的索
引位置是原数组中的位置+原数组长度

其实hash值的对应的新数组下标是不是需要加上旧数组的长度，只需要看看hash值&旧数组长度(hash&oldTable.length)是不是1就行了如果是1的话就是原数组中的位置+原数组长度，0的话就是原数组中的位置

JDK1.7中的扩容方法

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);// 新数组替换原数组table = newTable;// 新阈值threshold = (int)(newCapacity * loadFactor);}void transfer(Entry[] newTable) {// 源数组Entry[] src = table;int newCapacity = newTable.length;for (int j = 0; j < src.length; j++) {// 将元素赋值给eEntry<K,V> e = src[j];if (e != null) {// 将原来位置的元素置为null，方便GCsrc[j] = null;do {Entry<K,V> next = e.next;// 重新计算元素在新数组中的位置int i = indexFor(e.hash, newCapacity);e.next = newTable[i];newTable[i] = e;e = next;} while (e != null);}}}static int indexFor(int h, int length) {return h & (length-1);}

JDK1.8中的扩容方法

final Node<K, V>[] resize() {// 源数组Node<K, V>[] oldTab = table;// 原来的数组容量int oldCap = (oldTab == null) ? 0 : oldTab.length;// 原来数组的阈值int oldThr = threshold;/*newCap：新数组的容量，初始值为0newThr：新数组的阈值，初始值为0*/int newCap, newThr = 0;// 判断原来的数组大小是否不为0if (oldCap > 0) {/*原数组的容量已经大于等于最大容量将最大值赋值给原来的阈值并返回原数组*/if (oldCap >= MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return oldTab;}/*(newCap = oldCap << 1)：将原数组左移一位，也就是扩大为原来的2倍并赋值给新容量newCap新容量小于最大容量值且原数组容量要大于默认的初始容量16则将阈值扩大*/else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)// 阈值扩大一倍newThr = oldThr << 1; // double threshold}/*原阈值大于0则赋值给新容量这里肯能有疑问为啥将原数组阈值大小赋值给新容量？看看前面的JDK1.8中的有参构造方法就明白了，在tableSizeFor方法体内部将计算后的数据直接赋值给threshold边界值了*/else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;else {               // zero initial threshold signifies using defaults/*进入else则说明原来数组的容量和阈值都是0，则进行初始化默认值newCap：赋值初始值16newThr：新阈值=0.75*16=12*/newCap = DEFAULT_INITIAL_CAPACITY;newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}/*新阈值还是初始值0则计算新阈值*/if (newThr == 0) {// ft = 新容量*负载因子float ft = (float) newCap * loadFactor;// 新数组容量不超过最大值且ft小于最大值则取ft为新阈值newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?(int) ft : Integer.MAX_VALUE);}// 将新阈值赋值给成员变量thresholdthreshold = newThr;// 创建新长度的数组newTab@SuppressWarnings({"rawtypes", "unchecked"})Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];// 将新数组赋值给成员变量tabletable = newTab;if (oldTab != null) {// 遍历原数组，将数据放到新的数组中去for (int j = 0; j < oldCap; ++j) {// 用来保存遍历中的元素Node<K, V> e;if ((e = oldTab[j]) != null) {/*将原数组中索引位置的元素赋值给e后，将索引位置的元素置为null方便GC*/oldTab[j] = null;/*判断数组是否有下一个引用，如果e.next为空则说明不是链表，直接将元素放到数组中即可*/if (e.next == null)/*将原数组中的原素放到新数组中e.hash & (newCap - 1)：这一步是计算元素放到新数组的索引位置*/newTab[e.hash & (newCap - 1)] = e;/*判断是否是红黑树*/else if (e instanceof TreeNode)// 说明是红黑树来，则调用相关方法处理((TreeNode<K, V>) e).split(this, newTab, j, oldCap);else {/*到了else说明是链表loHead：下标不变情况下的链表头loTail：下标不变情况下的链表尾hiHead：下标改变情况下的链表头hiTail：下标改变情况下的链表尾*/Node<K, V> loHead = null, loTail = null;Node<K, V> hiHead = null, hiTail = null;Node<K, V> next;do {// 将e的next节点赋值给next变量next = e.next;// 这里来判断如果等于true e这个结点在resize之后不需要移动位置，也就是对应数组下标不变，这里也就是判断是不是新索引位置=原数组长度+原数组位置if ((e.hash & oldCap) == 0) {if (loTail == null)loHead = e;elseloTail.next = e;loTail = e;} else {if (hiTail == null)hiHead = e;elsehiTail.next = e;hiTail = e;}} while ((e = next) != null);// 将next赋值给e，继续循环直到next为空// 原索引放到数组中if (loTail != null) {loTail.next = null;newTab[j] = loHead;}// 原索引+oldCap放到数组中if (hiTail != null) {hiTail.next = null;newTab[j + oldCap] = hiHead;}}}}}return newTab;}

后面的remove和get方法相对比较容易一点，下面都是以JDK8为例，大家可以自己去看看源码对比对比

删除方法 remove()

删除方法就是首先先找到元素的位置，如果是链表就遍历链表找到元素之后删除。如果是用红黑树就遍历树然后找到之后做删除，树小于 6 的时候要转链表。

查找元素方法 get()

主要是getNode方法

 public V get(Object key) {Node<K, V> e;return (e = getNode(hash(key), key)) == null ? null : e.value;}final Node<K, V> getNode(int hash, Object key) {// 保存数组Node<K, V>[] tab;// first：保存头结点  e：保存next节点Node<K, V> first, e;// 保存数组长度int n;// 保存key值K k;/*tab = table：将数组赋值给tabn = tab.length：记录数组长度first = tab[(n - 1) & hash]：将key对应的索引位置中的元素赋值给first*/if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {// 判断头结点是否是要找的元素，是的话直接返回if (first.hash == hash && // always check first node((k = first.key) == key || (key != null && key.equals(k))))return first;/*将next节点赋值给e*/if ((e = first.next) != null) {/*判断是否是红黑树节点，是的话则从树中查找节点并返回数据*/if (first instanceof TreeNode)return ((TreeNode<K, V>) first).getTreeNode(hash, key);/*遍历链表查找数据并返回*/do {if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))return e;} while ((e = e.next) != null);}}return null;}

几种遍历HashMap的方式

 public static void main(String[] args){HashMap<String,Integer> hashMap = new HashMap<>(16);hashMap.put("科比",36);hashMap.put("韦德",23);hashMap.put("詹姆斯",38);hashMap.put("安东尼",30);hashMap.put("保罗",25);// 分别遍历key和valuesiteratorMap_1(hashMap);// 使用迭代器遍历iteratorMap_2(hashMap);// 通过 get 方式iteratorMap_3(hashMap);// 通过lambda方式iteratorMap_4(hashMap);}

1.分别遍历key和value（不常用）

   /*** 分别遍历key和values* @param hashMap*/private static void iteratorMap_1(HashMap<String, Integer> hashMap) {for (String key : hashMap.keySet()) {System.out.println(key);}for (Integer value : hashMap.values()) {System.out.println(value);}}

2.通过迭代器迭代（推荐）

/*** 使用迭代器遍历* @param hashMap*/private static void iteratorMap_2(HashMap<String, Integer> hashMap) {for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {System.out.println(entry.getKey()+"=====>"+entry.getValue());}}

3.通过get方式（不推荐使用）

根据阿里开发手册，不建议使用这种方式，因为迭代两次。keySet 获取 Iterator一次，还有通过 get 又迭代一次，降低性能。

    /*** 通过 get 方式* @param hashMap*/private static void iteratorMap_3(HashMap<String, Integer> hashMap) {for (String key : hashMap.keySet()) {Integer value = hashMap.get(key);System.out.println(key+"=====>"+value);}}

4.使用lambda表达式遍历（推荐）

    /*** 通过lambda* @param hashMap*/private static void iteratorMap_4(HashMap<String, Integer> hashMap) {hashMap.forEach((key,value)->System.out.println(key+"=====>"+value));}

如何给HashMap设置正确的初始容量

我们上面介绍过，HashMap 的扩容机制，就是当达到扩容条件时会进行扩容。HashMap 的扩容条件就是当 HashMap 中的元素个数（size）超过临界值（threshold）时就会自动扩容。所以，如果我们没有设置初始容量大小，随着元素的不断增加，HashMap 会有可能发生多次扩容，而 HashMap 中的扩容机制决定了每次扩容都需要重建 hash 表，是非常影响性能的。比如我们有7个元素要存放，我们设置初始容量为7，经过HashMap的处理他会给我们将容量设置为8，但是我们知道当元素个数超过8*0.75=6时就会进行一次扩容，也就是说我们设置的这个初始容量7其实是不对的。

因此初始化容量，设置的数值不同也会影响性能，那么当我们已知 HashMap 中即将存放的 Key、Value个数的时候，容量设置成多少为好呢？

关于设置 HashMap 的初始化容量大小：可以认为，当我们明确知道 HashMap 中元素的个数的时候，把默认容量设置成initialCapacity/ 0.75F + 1.0F 是一个在性能上相对好的选择，但是，同时也会牺牲些内存。而 Jdk 并不会直接拿用户传进来的数字当做默认容量，而是会进行一番运算，最终得到一个 2 的n次幂。同意以7为例，7/0.75+1=10，我们传入10经过HashMap处理会给一个16大小的HashMap这样就避免了频繁扩容，但是会浪费一些空间。

参考博客