Java7/8 中的 HashMap解析（1）

最新推荐文章于 2022-08-14 21:57:04 发布

zhekndang93

最新推荐文章于 2022-08-14 21:57:04 发布

阅读量204

点赞数

分类专栏：基础知识文章标签： JAVA MAP

本文链接：https://blog.csdn.net/zhekndang93/article/details/91404923

版权

基础知识专栏收录该内容

0 篇文章 0 订阅

订阅专栏

HashMap7源码分析及知识扩展

网上有很多对hashmap的解析，但是缺斤少两的还是很多，本文主要对 Java7/8 中的 HashMap 源码进行分析，也方便自己总结内容

hashmap数据结构
hashmap部分源码操作
扩展知识

hashmap数据结构

学习一个类，就从改类的数据结构看，方便我们理解，大家学过数据结构的都知道，常见的数据结构就这些线性表（顺序存储、链式存储）、栈、队列、树、图等等内容，后续也会有一篇文章专门来说明这些数据结构。下面是hashmap的数据结构：数组+单链表
在这里插入图片描述这个仅仅是示意图，因为没有考虑到数组要扩容的情况。
每个节点是一个Entry里面含有 key、value、next、hash 数据。
capacity：当前数组容量，始终保持 2^n，可以扩容，扩容后数组大小为当前的 2 倍。
loadFactor：负载因子，默认为 0.75。（就是一个扩容比例）
threshold：扩容的阈值，等于 capacity * loadFactor。
先记着这3个变量数据后面会详细在说到。

hashmap部分源码操作

构造函数：所有构造函数都会跑到下列方法，这块很简单，就是把扩容英子和默认大小进行一次设置，注意构造函数中并没有初始化数组。

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

       this.loadFactor = loadFactor;
       threshold = initialCapacity;
       init();
   }

put过程分析: 数组初始化，根据hash定位key，新增或替换内容

public V put(K key, V value) {
    // 当插入第一个元素的时候，需要先初始化数组大小
       if (table == EMPTY_TABLE) {
           inflateTable(threshold);
       }
        // 如果 key 为 null，感兴趣的可以往里看，最终会将这个 entry 放到 table[0] 中
       if (key == null)
           return putForNullKey(value);
          //1.求key的hash值
       int hash = hash(key);
         // 2. 找到对应的数组下标
       int i = indexFor(hash, table.length);
       // 3. 遍历一下对应下标处的链表，看是否有重复的 key 已经存在，
   //    如果有，直接覆盖，put 方法返回旧值就结束了
       for (Entry<K,V> e = table[i]; e != null; e = e.next) {
           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++;
       // 4. 不存在重复的 key，将此 entry 添加到链表中，细节后面说
       addEntry(hash, key, value, i);
       return null;
   }

数组初始化： capacity一定为2的n次方，初始化数组

private void inflateTable(int toSize) {
   // 保证数组大小一定是 2 的 n 次方。
   // 比如这样初始化：new HashMap(20)，那么处理成初始数组大小是 32
   int capacity = roundUpToPowerOf2(toSize);
   // 计算扩容阈值：capacity * loadFactor
   threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
   // 初始化数组
   table = new Entry[capacity];
   initHashSeedAsNeeded(capacity); //ignore
}

hash与计算数组中的位置： 主要目的为了数据更散列；取 hash 值的低 n 位。如在数组长度为 32 的时候，其实取的就是 key 的 hash 值的低 5 位（2进制），作为它在数组中的下标位置。

static int indexFor(int hash, int length) {
   // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
   return hash & (length-1);
}

添加节点到链表中 找到数组下标后，会先进行 key 判重，如果没有重复，就准备将新值放入到链表的表头。这个方法的主要逻辑就是先判断是否需要扩容，需要的话先扩容，然后再将这个新的数据插入到扩容后的数组的相应位置处的链表的表头。

void addEntry(int hash, K key, V value, int bucketIndex) {
  // 如果当前 HashMap 大小已经达到了阈值，并且新值要插入的数组位置已经有元素了，那么要扩容
  if ((size >= threshold) && (null != table[bucketIndex])) {
      // 扩容，后面会介绍一下
      resize(2 * table.length);
      // 扩容以后，重新计算 hash 值
      hash = (null != key) ? hash(key) : 0;
      // 重新计算扩容后的新的下标
      bucketIndex = indexFor(hash, table.length);
  }
  // 往下看
  createEntry(hash, key, value, bucketIndex);
}
// 这个很简单，其实就是将新值放到链表的表头，然后 size++
void createEntry(int hash, K key, V value, int bucketIndex) {
  Entry<K,V> e = table[bucketIndex];
  table[bucketIndex] = new Entry<>(hash, key, value, e);
  size++;
}

数组扩容

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

 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);
              }
              //获取新数组中的下标，1.8后有进行优化
              int i = indexFor(e.hash, newCapacity);
              e.next = newTable[i];
              newTable[i] = e;
              e = next;
          }
      }
  }

扩容就是用一个新的大数组替换原来的小数组，并将原来数组中的值迁移到新的数组中。
由于是双倍扩容，迁移过程中，会将原来 table[i] 中的链表的所有节点，分拆到新的数组的 newTable[i] 和 newTable[i + oldLength] 位置上。如原来数组长度是 16，那么扩容后，原来 table[0] 处的链表中的所有元素会被分配到新数组中 newTable[0] 和 newTable[16] 这两个位置。这块与capacity一定要为2^n后面会在讲述到。
put中key为空时候 在table[0]位置插入一个key为空的entry

private V putForNullKey(V value) {
      for (Entry<K,V> e = table[0]; e != null; e = e.next) {
          if (e.key == null) {
              V oldValue = e.value;
              e.value = value;
              e.recordAccess(this);
              return oldValue;
          }
      }
      modCount++;
      addEntry(0, null, value, 0);
      return null;
  }

get操作过程分析
1.根据 key 计算 hash 值。
2.找到相应的数组下标：hash & (length - 1)。
3.遍历该数组位置处的链表，直到找到相等(==或equals)的 key。

public V get(Object key) {
  // 之前说过，key 为 null 的话，会被放到 table[0]，所以只要遍历下 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;
  }

  int hash = (key == null) ? 0 : hash(key);
  // 确定数组下标，然后从头开始遍历链表，直到找到为止
  for (Entry<K,V> e = table[indexFor(hash, table.length)];
       e != null;
       e = e.next) {
      Object k;
      //这里可以发现 判断依据 hash 还有equals
      //两个数据放入map中是否相等要实现这两个方法
      if (e.hash == hash &&
          ((k = e.key) == key || (key != null && key.equals(k))))
          return e;
  }
  return null;
}

扩展知识

详细说明下为何capacity一定要为2^n倍把。

两个好处点：
1.HashMap为了存取高效，要尽量较少碰撞，就是要尽量把数据分配均匀，每个链表长度大致相同，这个实现就在把数据存到哪个链表中的算法；
这个算法实际就是取模，hash%length，计算机中直接求余效率不如位移运算，源码中做了优化hash&(length-1)，hash%length==hash&(length-1)的前提是length是2的n次方；
为什么这样能均匀分布减少碰撞呢？2的n次方实际就是1后面n个0，2的n次方-1 实际就是n个1；
例如长度为9时候，3&(9-1)=0 2&(9-1)=0 ，都在0上，碰撞了；
例如长度为8时候，3&(8-1)=3 2&(8-1)=2 ，不同位置上，不碰撞；
其实就是按位“与”的时候，每一位都能 &1 ，也就是和1111……1111111进行与运算

0000 0011 3
& 0000 1000 8
= 0000 0000 0

0000 0010 2
& 0000 1000 8
= 0000 0000 0

0000 0011 3
& 0000 0111 7
= 0000 0011 3

0000 0010 2
& 0000 0111 7
= 0000 0010 2

2.扩容时候旧的数组数据移动到新的数组上必定是在table[n]或者table[n+oldSize]上。因为我们知道扩容也是2倍扩容那么在2进制表达上就是左移1位。
以下图为例，其中图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，n代表length。
在这里插入图片描述元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：

resize过程中不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图（一方面位运算更快，另一方面抗碰撞的Hash函数其实挺耗时的）。1.8后进行改造

本篇文章先这样后续文章会对8中的map优化内容进行讲解

引用参考：
https://javadoop.com/post/hashmap
https://blog.csdn.net/zs319428/article/details/81982770
https://blog.csdn.net/dalong3976/article/details/83934609

zhekndang93

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java7/8 中的 HashMap解析（1）

网上有很多对hashmap的解析，但是缺斤少两的还是很多，本文主要对 Java7/8 中的 HashMap 源码进行分析，也方便自己总结内容hashmap数据结构hashmap部分源码操作...
复制链接

扫一扫