HashMap源码理解

HashMap理解

  1. HashMap定义
  2. HashMap实现机制
  3. HashMap与HashTable的主要区别
  4. 关键属性
  5. 构造函数
  6. put和get方法
    6.1. 存储数据
    6.2. 扩容容
    6.3. 数据读取
  7. HashMap的性能参数

1. HashMap定义

看下HashMap的定义:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

HashMap继承了AbstractMap抽象类,提供了Map接口骨干方法的实现。

This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface.

HashMap实现了Map、Cloneable、Serializable接口。

2. HashMap实现机制

HashMap底层是基于数组和链表来实现的,主要通过计算散列码来决定存储的位置。HashMap中主要是通过key的hashCode来计算hash值的,只要hashCode相同,计算出来的hash值就一样。如果存储的对象对多了,就有可能不同的对象所算出来的hash值是相同的,这就出现了所谓的hash冲突。学过数据结构的同学都知道,解决hash冲突的方法有很多,HashMap底层是通过链表来解决hash冲突的。

HashMap源码理解_第1张图片
hashmap链表图.jpg

图中,紫色部分即代表哈希表,也称为哈希数组,数组的每个元素都是一个单链表的头节点,链表是用来解决冲突的,如果不同的key映射到了数组的同一位置处,就将其放入单链表中。
下面来看看单链表节点的Entry类实现代码:


  /** Entry是单向链表。
  * 它是 “HashMap链式存储法”对应的链表。
  * 它实现了Map.Entry 接口,即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数
  */
  static class Entry implements Map.Entry {
      final K key;
      V value;
      Entry next;
      int hash;

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

      public final K getKey() {
          return key;
      }

      public final V getValue() {
          return value;
      }

      public final V setValue(V newValue) {
          V oldValue = value;
          value = newValue;
          return oldValue;
      }

      // 若两个Entry的“key”和“value”都相等,则返回true。
      public final boolean equals(Object o) {
          if (!(o instanceof Map.Entry))
              return false;
          Map.Entry e = (Map.Entry)o;
          Object k1 = getKey();
          Object k2 = e.getKey();
          if (k1 == k2 || (k1 != null && k1.equals(k2))) {
              Object v1 = getValue();
              Object v2 = e.getValue();
              if (v1 == v2 || (v1 != null && v1.equals(v2)))
                  return true;
          }
          return false;
      }

      // key的hashCode 异或 value的hashCode
      public final int hashCode() {
          return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
      }

      public final String toString() {
          return getKey() + "=" + getValue();
      }

      /**
      * This method is invoked whenever the value in an entry is
      * overwritten by an invocation of put(k,v) for a key k that's already
      * in the HashMap.
      */
      void recordAccess(HashMap m) {
      }

      /**
      * This method is invoked whenever the entry is
      * removed from the table.
      */
      void recordRemoval(HashMap m) {
      }
  }

HashMap其实就是一个Entry数组,Entry对象中包含了键和值,其中next也是一个Entry对象,它就是用来处理hash冲突的,形成一个链表。

3. HashMap与HashTable的主要区别

  • 定义。HashMap实现了AbstractMap抽象类,而HashTable实现的是比较老的Dictionary抽象类.

  • 值存储。HashMap可以存储key为null、value为null的值,而HashTable不允许存储key为null或者value为null的值,会抛出NullPointerException异常。

  • 线程同步。HashMap是线程不安全的。HashTable是线程安全的,其方法包含synchronized关键字实现线程安全。

  • hash值计算。HashMap计算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();

      // This function ensures that hashCodes that differ only by
      // constant multiples at each bit position have a bounded
      // number of collisions (approximately 8 at default load factor).
      h ^= (h >>> 20) ^ (h >>> 12);
      return h ^ (h >>> 7) ^ (h >>> 4);
  }

HashTable计算hash值:


  private int hash(Object k) {
      // hashSeed will be zero if alternative hashing is disabled.
      return hashSeed ^ k.hashCode();
  }

  • 默认大小。HashMap默认数组大小为16,加载因子为0.75,重新hash阈值为12。
    HashTable默认数组大小为11,加载因子为0.75,重新hash阈值为8。

  • 扩容方式。HashMap中的数组容量大小始终保证为2的指数。重新hash,扩充容量方式为:当前容量大小*2。

    HashTable扩容方式为:int newCapacity = oldCapacity * 2 + 1。

  • 成员方法不同。Hashtable包含一些旧的方法,如contains方法。

4. 关键属性


  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16  默认初始容量
  static final int MAXIMUM_CAPACITY = 1 << 30;    // 最大容量
  static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认初识加载因子为0.75
  transient int size; // 实际存储的key-value的数量
  int threshold;  // 临界值 当实际大小超过临界值时,会进行扩容threshold = 加载因子*容量
  transient int modCount; // 被修改的次数
  final float loadFactor; // 加载因子

其中loadFactor加载因子是表示Hash表中元素的填满的程度.
若:加载因子越大,填满的元素越多。好处是:空间利用率高了,但:冲突的机会加大了,冲突的机会越大,则查找的成本越高。
反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.表中的数据将过于稀疏(很多空间还没用,就开始扩容了)链表长度会越来越长,查找效率降低。

如果机器内存足够,并且想要提高查询速度的话可以将加载因子设置小一点;相反如果机器内存紧张,并且对查询速度没有什么要求的话可以将加载因子设置大一点。不过一般我们都不用去设置它,让它取默认值0.75就好了。

5. 构造函数


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

  public HashMap(int initialCapacity) {
      this(initialCapacity, DEFAULT_LOAD_FACTOR);
  }

  public HashMap() {
      this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
  }

  // 构造一个与给定的 Map 具有相同映射关系的新哈希表。
  public HashMap(Map m) {
      this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                    DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
      inflateTable(threshold);

      putAllForCreate(m);
  }

这么多的构造函数,主要还是调用第一个构造函数。我们也没有看到Entry[]数据的创建,所以当前的table还只是一个默认的空数据(EMPTY_TABLE),并没有初始化数组的容量。如果不设置容量参数和加载因子的话,默认初始容量为16,默认加载因子为0.75。
最后一个对于集成map的集合类的初始化就进行了Entry数组的设置。inflateTable方法初始化一个容量膨胀到2的整数次幂大于等于(threshold-1)<<1的值的table。


  private void inflateTable(int toSize) {
      // Find a power of 2 >= toSize
      int capacity = roundUpToPowerOf2(toSize);

      threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
      table = new Entry[capacity];
      initHashSeedAsNeeded(capacity);
  }

  private static int roundUpToPowerOf2(int number) {
      // assert number >= 0 : "number must be non-negative";
      return number >= MAXIMUM_CAPACITY
              ? MAXIMUM_CAPACITY
              : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
  }

  // 返回二进制中最高位为1的值  也可以说小于等于i的最大2的次幂
  public static int highestOneBit(int i) {
      // HD, Figure 3-1
      i |= (i >>  1);
      i |= (i >>  2);
      i |= (i >>  4);
      i |= (i >>  8);
      i |= (i >> 16);
      return i - (i >>> 1);
  }

  final boolean initHashSeedAsNeeded(int capacity) {
      boolean currentAltHashing = hashSeed != 0;
      boolean useAltHashing = sun.misc.VM.isBooted() &&
              (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
      boolean switching = currentAltHashing ^ useAltHashing;
      if (switching) {
          hashSeed = useAltHashing
              ? sun.misc.Hashing.randomHashSeed(this)
              : 0;
      }
      return switching;
  }

当length为2的n次方时,h&(length – 1)就相当于对length取模,而且速度比直接取模快得多,这是HashMap在速度上的一个优化。简单的解释就是当length为2的n次方时,length-1的二进制为n个1,这样来做&运算得到的值差异化最大,hash冲突也就最少。
然后是阈值的计算,以及进行table初始化数组。
其中initHashSeedAsNeeded方法用于初始化hashSeed参数,其中hashSeed用于计算key的hash值,它与key的hashCode进行按位异或运算。这个hashSeed是一个与实例相关的随机值,主要用于解决hash冲突。


  private int hash(Object k) {
      int h = hashSeed;
      if (0 != h && k instanceof String) {
          return sun.misc.Hashing.stringHash32((String) k);
      }

      h ^= k.hashCode();

      // This function ensures that hashCodes that differ only by
      // constant multiples at each bit position have a bounded
      // number of collisions (approximately 8 at default load factor).
      h ^= (h >>> 20) ^ (h >>> 12);
      return h ^ (h >>> 7) ^ (h >>> 4);
  }

6. put和get方法

6.1. 存储数据


  public V put(K key, V value) {
      if (table == EMPTY_TABLE) {
          inflateTable(threshold);
      }
      if (key == null)
          return putForNullKey(value);
      int hash = hash(key);
      int i = indexFor(hash, table.length);
      // 循环遍历Entry数组,若“该key”对应的键值对已经存在,则用新的value取代旧的value。然后退出!
      for (Entry 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++;
      // 将key-value添加到table[i]处将key-value添加到table[i]处
      addEntry(hash, key, value, i);
      return null;
  }

上面的程序中用到了一个重要的内部接口:Map.Entry,每个Map.Entry就是一个key-value对。从上面的程序中可以看出:当系统决定存储HashMap中的key-value时,完全没有考虑Entry中的value,仅仅只是根据key来计算并存储没有Entry的存储位置。这也说明了前面的结论:我们完全可以把 Map 集合中的 value 当成 key 的附属,当系统决定了 key 的存储位置之后,value 随之保存在那里即可。

我们慢慢的来分析这个函数,第2和3行的作用就是处理key值为null的情况,我们看看putForNullKey(value)方法:


  private V putForNullKey(V value) {
      for (Entry 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;
  }

如果key为null的话,hash值为0,对象存储在数组中索引为0的位置。即table[0]。

通过key得到hash码之后,就会通过hash码去计算出应该存储在数组中的索引,计算索引的函数如下:


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

这个我们要重点说下,我们一般对哈希表的散列很自然地会想到用hash值对length取模(即除法散列法),Hashtable中也是这样实现的,这种方法基本能保证元素在哈希表中散列的比较均匀,但取模会用到除法运算,效率很低,HashMap中则通过h&(length-1)的方法来代替取模,同样实现了均匀的散列,但效率要高很多,这也是HashMap对Hashtable的一个改进。


  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 createEntry(int hash, K key, V value, int bucketIndex) {
      Entry e = table[bucketIndex];
      table[bucketIndex] = new Entry<>(hash, key, value, e);
      size++;
  }

参数bucketIndex就是indexFor函数计算出来的索引值,通过判断size大于临界值和当前定位不为空时就扩容,扩容为原来的两倍。该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点。

6.2. 扩容容

重新调整HashMap的大小,newCapacity是调整后的单位.


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

新建了一个HashMap的底层数组,上面代码中第10行为调用transfer方法,将HashMap的全部元素添加到新的HashMap中,并重新计算元素在新的数组中的索引位置

当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,数组扩容这个操作也会出现在ArrayList中,这是一个常用的操作,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。
如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。

6.3. 数据读取


  public V get(Object key) {
      if (key == null)
          return getForNullKey();
      Entry entry = getEntry(key);

      return null == entry ? null : entry.getValue();
  }

有了上面存储时的hash算法作为基础,理解起来这段代码就很容易了。从上面的源代码中可以看出:从HashMap中get元素时,首先计算key的hashCode,找到数组中对应位置的某一元素,然后通过key的equals方法在对应位置的链表中找到需要的元素。

7. HashMap的性能参数

HashMap 包含如下几个构造器:

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

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

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

HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数,它们是初始容量initialCapacity和加载因子loadFactor。

initialCapacity:HashMap的最大容量,即为底层数组的长度。

loadFactor:负载因子loadFactor定义为:散列表的实际元素数目(n)/ 散列表的容量(m)。

负载因子衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。对于使用链表法的散列表来说,查找一个元素的平均时间是O(1+a),因此如果负载因子越大,对空间的利用更充分,然而后果是查找效率的降低;如果负载因子太小,那么散列表的数据将过于稀疏,对空间造成严重浪费。

HashMap的实现中,通过threshold字段来判断HashMap的最大容量:

threshold = (int)(capacity * loadFactor);

结合负载因子的定义公式可知,threshold就是在此loadFactor和capacity对应下允许的最大元素数目,超过这个数目就重新resize,以降低实际的负载因子。默认的的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时, resize后的HashMap容量是容量的两倍:

你可能感兴趣的:(HashMap源码理解)