深入讲解HashMap

原文链接:https://my.oschina.net/u/1458864/blog/266254

先从构造函数讲起吧

HashMap有很多个构造函数,不过我们比较常用的是不带参数的默认构造函数,其源代码如下:

public HashMap() {

        this.loadFactor = DEFAULT_LOAD_FACTOR;

        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);

        table = new Entry[DEFAULT_INITIAL_CAPACITY];

        init();

    }

事实上,HashMap的所有键值对被存放在一个Entry数组中(变量table),DEFAULT_INITIAL_CAPACITY(为16)即是默认的Entry数组长度的初始值,当然我们也可以自定义entry数组的长度,但是长度必须为2的n次方,为什么要如此,下面会讲解到。

Entry数组每一个索引处都可以存放一个Entry链(通过下面Entry的构造函数可以发现Entry对象可以指明它的下一个对象,所以多个Entry对象可以以Entry链的形式存在)

Entry类的构造函数如下:

 Entry(int h, K k, V v, Entry<K,V> n) {

            value = v;

            next = n;

            key = k;

            hash = h;

        }

每个存入HashMap的键值对都会以Entry对象的形式储存,Entry类除了拥有key和value变量外,还有两个重要的变量:

next指明了下一个Entry对象
hash是该Entry对象的哈希值(Hash码)

HashMap在存入键值对时首先会根据key的hashCode() 返回值来计算 Hash 码,然后通过该Hash码计算出这个这个键值对要放在数组的哪个索引处,

如果该索引处还没有存放entry对象则用要存入的键值对新建一个Entry对象并将此对象存放于这个索引处,并将next变量赋为null;

如果该索引已经存在entry链,则遍历该entry链,如果entry链中含有key和要存入的key相等的entry对象,则将该对象的value值替换成我们要存入的value;

如果该索引已经存在entry链,且entry链中没有key和要存入的key相等的entry对象,则用要存入的键值对新建一个entry对象,然后将此对象存入改索引处,并将next指向该索引处之前的对象,也就是说将新的entry对象放入到entry链的链头中;

存入键值对的方法源代码如下:

 public V put(K key, V value) 

 { 

  // 如果 key 为 null,调用 putForNullKey 方法进行处理

  if (key == null) 

   return putForNullKey(value); 

  // 根据 key 的 keyCode 计算 Hash 值

  int hash = hash(key.hashCode()); 

  // 搜索指定 hash 值在对应 table 中的索引

   int i = indexFor(hash, table.length);

  // 如果 i 索引处的 Entry 不为 null,通过循环不断遍历 e 元素的下一个元素

  for (Entry<K,V> e = table[i]; e != null; e = e.next) 

  { 

   Object k; 

   // 找到指定 key 与需要放入的 key 相等(hash 值相同

   // 通过 equals 比较放回 true)

   if (e.hash == hash && ((k = e.key) == key 

    || key.equals(k))) 

   { 

    V oldValue = e.value; 

    e.value = value; 

    e.recordAccess(this); 

    return oldValue; 

   } 

  } 

  // 如果 i 索引处的 Entry 为 null,表明此处还没有 Entry 

  modCount++; 

  // 将 key、value 添加到 i 索引处

  addEntry(hash, key, value, i); 

  return null; 

 }

计算Hash码的方法hash是一个纯粹的数学计算,其方法如下:

static int hash(int h) 

{ 

    h ^= (h >>> 20) ^ (h >>> 12); 

    return h ^ (h >>> 7) ^ (h >>> 4); 

}

对于任意给定的对象,只要它的 hashCode() 返回值相同,那么程序调用 hash(int h) 方法所计算得到的 Hash 码值总是相同的。

接下来程序会调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。

indexFor(int h, int length) 方法的代码如下:

static int indexFor(int h, int length) 

{ 

    return h & (length-1); 

}

这个方法非常巧妙,它总是通过 h &(table.length -1) 来得到该对象的保存位置——而 HashMap 底层数组的长度总是 2 的 n 次方

当 length 总是 2 的倍数时,h & (length-1) 将是一个非常巧妙的设计:

假设 h=5,length=16, 那么 h & length - 1 将得到 5;

如果 h=6,length=16, 那么 h & length - 1 将得到 6 ……如果 h=15,length=16, 那么 h & length - 1 将得到 15;

但是当 h=16 时 , length=16 时,那么 h & length - 1 将得到 0 了;

当 h=17 时 , length=16 时,那么 h & length - 1 将得到 1 了……

这样保证计算得到的索引值总是位于 table 数组的索引之内

其实看到这里也许你问,为什么不直接将hash码除以length然后取余数来获得索引值呢,这样不也是也可以实现索引值总是位于table数组的索引之内么?

原因我觉得应该是:与运算比除运算来的更有效率

 

当向 HashMap 中添加 key-value 对,由其 key 的 hashCode() 返回值决定该 key-value 对(就是 Entry 对象)的存储位置。

当两个 Entry 对象的 key 的 hashCode() 返回值相同时,将由 key 通过 eqauls() 比较值决定是采用覆盖行为(返回 true),还是产生 Entry 链(返回 false)。

上面程序中还调用了 addEntry(hash, key, value, i); 代码,其中 addEntry 是 HashMap 提供的一个包访问权限的方法,该方法仅用于添加一个 key-value 对。

下面是该方法的代码:

void addEntry(int hash, K key, V value, int bucketIndex) 

{ 

    // 获取指定 bucketIndex 索引处的 Entry 

    Entry<K,V> e = table[bucketIndex];   // ①

    // 将新创建的 Entry 放入 bucketIndex 索引处,并让新的 Entry 指向原来的 Entry 

    table[bucketIndex] = new Entry<K,V>(hash, key, value, e); 

    // 如果 Map 中的 key-value 对的数量超过了极限

    if (size++ >= threshold) 

        // 把 table 对象的长度扩充到 2 倍。

        resize(2 * table.length);   // ②

}

size:该变量保存了该 HashMap 中所包含的 key-value 对的数量

threshold是阀值的意思,阀值等于Entry数组长度乘以负载因子,从上面的例子可以看出当size++ >= threshold 时,HashMap 会自动调用 resize 方法扩充 HashMap 的容量。每扩充一次,HashMap 的容量就增大一倍。

loadFactor即负载因子,默认的负载因子(DEFAULT_INITIAL_CAPACITY )为0.75负载

增大负载因子可以减少 Hash 表(就是那个 Entry 数组)所占用的内存空间,但会增加查询数据的时间开销,而查询是最频繁的的操作(HashMap 的 get() 与 put() 方法都要用到查询);

减小负载因子会提高数据查询的性能,但会增加 Hash 表所占用的内存空间

掌握了上面知识之后,我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值;

如果程序比较关心空间开销、内存比较紧张,可以适当地增加负载因子;如果程序比较关心时间开销,内存比较宽裕则可以适当的减少负载因子。通常情况下,程序员无需改变负载因子的值。

如果开始就知道 HashMap 会保存多个 key-value 对,可以在创建时就使用较大的初始化容量,如果 HashMap 中 Entry 的数量一直不会超过极限容量(capacity * load factor),HashMap 就无需调用 resize() 方法重新分配 table 数组,从而保证较好的性能。当然,开始就将初始容量设置太高可能会浪费空间(系统需要创建一个长度为 capacity 的 Entry 数组),因此创建 HashMap 时初始化容量设置也需要小心对待。

 

接下来我们来看一下HashMap 的读取实现

当 HashMap 的每个 bucket 里存储的 Entry 只是单个 Entry ——也就是没有通过指针产生 Entry 链时,此时的 HashMap 具有最好的性能:当程序通过 key 取出对应 value 时,系统只要先计算出该 key 的 hashCode() 返回值,在根据该 hashCode 返回值找出该 key 在 table 数组中的索引,然后取出该索引处的 Entry,最后返回该 key 对应的 value 即可。

HashMap 类的 get(K key) 方法代码:

 public V get(Object key) 

 { 

  // 如果 key 是 null,调用 getForNullKey 取出对应的 value 

  if (key == null) 

   return getForNullKey(); 

  // 根据该 key 的 hashCode 值计算它的 hash 码

  int hash = hash(key.hashCode()); 

  // 直接取出 table 数组中指定索引处的值,

  for (Entry<K,V> e = table[indexFor(hash, table.length)]; 

   e != null; 

   // 搜索该 Entry 链的下一个 Entr 

   e = e.next)    // ①

  { 

   Object k; 

   // 如果该 Entry 的 key 与被搜索 key 相同

   if (e.hash == hash && ((k = e.key) == key 

    || key.equals(k))) 

    return e.value; 

  } 

  return null; 

 }

对于 HashMap 及其子类而言,它们采用 Hash 算法来决定集合中元素的存储位置。当系统开始初始化 HashMap 时,系统会创建一个长度为 capacity 的 Entry 数组,这个数组里可以存储元素的位置被称为“桶(bucket)”,每个 bucket 都有其指定索引,系统可以根据其索引快速访问该 bucket 里存储的元素。

无论何时,HashMap 的每个“桶”只存储一个元素(也就是一个 Entry),由于 Entry 对象可以包含一个引用变量(就是 Entry 构造器的的最后一个参数)用于指向下一个 Entry,因此可能出现的情况是:HashMap 的 bucket 中只有一个 Entry,但这个 Entry 指向另一个 Entry ——这就形成了一个 Entry 链。如图 1 所示:



图 1. HashMap 的存储示意

转载于:https://my.oschina.net/u/1458864/blog/266254

展开阅读全文
博主设置当前文章不允许评论。

没有更多推荐了,返回首页