Java中关于HashMap源码的研究

1.基础知识

1.数组

数组存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难。

2.链表

链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特点是：寻址困难，插入和删除容易。

3.哈希表

那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表。哈希表（(Hash table）既满足了数据的查找方便，同时不占用太多的内容空间，使用也十分方便。

2.具体实现

由于HashMap使用的是数组+链表的方式来存储数据的。那么我们先研究下每一个元素存放数据的数据结构--HashMap的内部类。

1.基本元素

Entry<K,V>是HashMap的基本元素单位其本身就是一个链表存储方式。

//定义为静态内部类,使用时不需要外部类的对象
static class Entry<K, V> implements Map.Entry<K, V> {
  //Key为HashMap定义的key,为保证key的稳定性定义为不可修改的final类型
  final K key;
  //value为HashMap的value
  V value;
  //存储的是如果哈希值相同下一个元素的引用。这是一个典型的链表结构
  Entry<K, V> next;
  //hash为hash(key)%length（hashMap长度默认为16）运算后的结果
  int hash;

  //默认构造方法
  Entry(int h, K k, V v, Entry<K, V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
  }
  //后面是一些重写toString、equals、 hashCode等操作就省略了。
}

上面的代码多一句嘴，在JDK1.8中以上的版本中我们会看到Node和TreeNode的基础元素类型是因为JDK1.8版本的HashMap采用数组+链表+红黑树来实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

2.基础结构

下面我们看看HashMap的基础结构Entry数组。

static final Entry<?,?>[] EMPTY_TABLE = {};

transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

Entry数组的长度必须是2的幂。至于为什么是2的幂这个问题不是本文的重点。

可以参考

HashMap实现原理及源码分析|

HashMap剖析

3.存取实现。

1.put

既然HashMap的基础是数组那么为什么能够随机存取。而不是数组那样一个一个add存储呢。

为了解释清楚这个概念。需要了解下HashMap内部的一些属性（成员变量）

1.size 这个属性表示了HashMap中所有KV对的数量，包含挂在链表中的KV对。

2.capacity 这个属性表示HashMap的哈希表的长度，也就是table的长度。

3.loadFactor

这个属性表示装载因子（用来形容是否装满，默认为0.75f），用来当HashMap的哈希表是否需要扩容的最大比例。当前的实装的因子为size/capacity。

4.threshold

这个属性表示HashMap的哈希表是否需要扩容的阈值。一般的来说当size大于这个值时会出发resize()操作（哈希散列表扩容的操作）。一般计算方法为capacity*loadFactor

5.modCount

这个属性表示HashMap表修改次数。给迭代器使用以保证Map迭代的完整性。

在项目第一次put是如果发现table的值为空那么就会启动一个初始化table的方法inflateTable(),这个名称很形象叫充气或者叫可以填充的。

if (table == EMPTY_TABLE) {
    inflateTable(threshold);
}
//table初始化方法
private void inflateTable(int toSize) {
    // 将其扩大值2的幂
    int capacity = roundUpToPowerOf2(toSize);

    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    //创建了一个大小为最大长度的entry数字
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}

数组建立完成后数组是有下标的。

我们只需要将key的哈希值与数组的最大长度取余。得出的结果作为存储的下标位置存入该数组。

具体实现如下：

//存值过程
int index = key.hashCode() % table.length;
Entry[index] = value;

具体是怎么返回索引的呢,h是key的哈希码 length 是table.length由于是全部填充故table的长度大约等于capacity.

& 与运算：参加运算的两个数据，按二进制位进行“与”运算。 运算规则：0&0=0; 0&1=0; 1&0=0; 1&1=1;

这里用了一个巧妙的算法。应为之前的约定length必定为2的幂。那么如果将length-1的到的结果一定是全1的二进制数字例如15（1111）、 7（111）、 3（11）、1（1）等。

那么将哈希值与这样的值做与运算得出的结果为h对length取余数。下面我举个栗子说明这一点。



我们用长度为16的length举例 16-1=15用二进制表示为（1111）

依据运算规则 0&1 = 0 1&1=1那么我们只要保证，二进制的数值最后4位为0那么他的余数一定是零。只要后面四位有任意一位是1数值都会被过滤出来。成为余数。

11110000(240)、10000（16）、100000（32）、110000（48）等一定是16的倍数。也就是说无论高于4位的数值是什么对余数结果都没有干扰。

对于2的幂作为模数取模，可以用&(2^{n-1)来替代%2}n，位运算比取模效率高很多,因为对2^n取模，只要不是低n位对结果的贡献显然都是0，会影响结果的只能是低n位。

static int indexFor(int h, int length) {
   return h & (length-1);
}

这里会出现一个问题如果2个key的哈希值冲突那么会出现什么结果呢。

这时HashMap的链表就登场了。当时我们在研究哈希表存储结构的时候有一个next属性。作用是指向下一个Entry，那么这两个Entry就以链表的形式存储在了一个哈希值下。

public V put(K key, V value) {
    //如果为空即第一次存储执行初始化数组table方法
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    //如果key为null这时就调用putForNullKey来存储value
    //这就是hashMap支持null key的原因。
    if (key == null)
        return putForNullKey(value);
    //上文讲到的计算index
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    //遍历链表
    //这时一个非常漂亮的递归遍历方式
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        //如果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;
}
//如果key是null
private V putForNullKey(V value) {
    //如果发现table[0]发现有key等于null的值则覆盖
    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++;
    //在table[0]添加一个新的KV
    addEntry(0, null, value, 0);
    return null;
}

//添加新元素
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);
}
//这时创建新的ENtry
void createEntry(int hash, K key, V value, int bucketIndex) {
    //首先将当前节点的元素存储起来
    Entry<K,V> e = table[bucketIndex];
    //创建一个新对象存储当前元素，将当原本元素存储到next中
    //如果两个元素碰撞那么后来者居上。
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    //将元素长度增加
    size++;
}

说下这个扩容的逻辑，就是这个方法resize 需要传入一个容量大小。每次扩容都是前一次容量的两倍。

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);
            }
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

2.get

取值逻辑

//存值过程
int index = key.hashCode() % table.length;
return Entry[index]

获取的逻辑就没有存储这么复杂了。

public V get(Object key) {
  //key为null时单独调用获取null的逻辑
   if (key == null)
       return getForNullKey();
  //获取value值
   Entry<K,V> entry = getEntry(key);
   return null == entry ? null : entry.getValue();
}
//key为null值得取值方法
private V getForNullKey() {
     if (size == 0) {
         return null;
     }
     //村吃时候是存在固定位置取时直接从table[0]位置读取
     for (Entry<K,V> e = table[0]; e != null; e = e.next) {
         if (e.key == null)
             return e.value;
     }
     return null;
 }
 //取值逻辑 此方法不能重写。
 final Entry<K,V> getEntry(Object key) {
       if (size == 0) {
           return null;
       }

       int hash = (key == null) ? 0 : hash(key);
       //循环遍历链表查找到值后返回 如果没有返回null
       for (Entry<K,V> e = table[indexFor(hash, table.length)];
            e != null;
            e = e.next) {
           Object k;
           if (e.hash == hash &&
               ((k = e.key) == key || (key != null && key.equals(k))))
               return e;
       }
       return null;
   }

3.remove、clear、containsValue、containsKey

//依据key移除元素
public V remove(Object key) {
  //依据key的哈希遍历链表然后移除元素
   Entry<K,V> e = removeEntryForKey(key);
   return (e == null ? null : e.value);
}

//clear调用了arrays全填充操作
public void clear() {
    modCount++;
    Arrays.fill(table, null);
    size = 0;
}
//简单粗暴的遍历全部元素判断是否有该value.效率极其低下
public boolean containsValue(Object value) {
    if (value == null)
        return containsNullValue();

    Entry[] tab = table;
    for (int i = 0; i < tab.length ; i++)
        for (Entry e = tab[i] ; e != null ; e = e.next)
            if (value.equals(e.value))
                return true;
    return false;
}
//判断Key是否存在.很高效
public boolean containsKey(Object key) {
    return getEntry(key) != null;
}

4.Iterator

首先我们先看下一个抽象哈希迭代器

private abstract class HashIterator<E> implements Iterator<E> {

    Entry<K,V> next;        // 下一个迭代的元素
    int expectedModCount;   // 开始迭代修改书
    int index;              // 当前的标记
    Entry<K,V> current;     // 当前的实例
    //初始化迭代器给next赋值
    HashIterator() {
      expectedModCount = modCount;
      if (size > 0) { // advance to first entry
          Entry[] t = table;
          while (index < t.length && (next = t[index++]) == null);
      }
    }

    public final boolean hasNext() {
      return next != null;
    }
    //读取下一个元素
    final Entry<K,V> nextEntry() {
      if (modCount != expectedModCount)
          throw new ConcurrentModificationException();
      Entry<K,V> e = next;
      if (e == null)
          throw new NoSuchElementException();

      if ((next = e.next) == null) {
          Entry[] t = table;
          while (index < t.length && (next = t[index++]) == null)
              ;
      }
      //将当前元素赋值给当前元素属性
      current = e;
      return e;
    }

    public void remove() {
      if (current == null)
          throw new IllegalStateException();
      if (modCount != expectedModCount)
          throw new ConcurrentModificationException();
      Object k = current.key;
      current = null;
      HashMap.this.removeEntryForKey(k);
      expectedModCount = modCount;
    }
}

HashMap提供了3中迭代器遍历方式

1.值遍历（values）

//对外提供的方法
//这里的values是Values这个内部类的实例
public Collection<V> values() {
    Collection<V> vs = values;
    return (vs != null ? vs : (values = new Values()));
}
//这是一个内部类实现了一个迭代器Collection<V>能接收valus这个实例这是向上造型
//这个实例返回的实际上是一个Map元素的映射因为基于map所以数值是动态变化的
private final class Values extends AbstractCollection<V> {
    public Iterator<V> iterator() {
        return newValueIterator();
    }
    public int size() {
        return size;
    }
    public boolean contains(Object o) {
        return containsValue(o);
    }
    public void clear() {
        HashMap.this.clear();
    }
}
//返回一个迭代器对象
Iterator<V> newValueIterator()   {
   return new ValueIterator();
}
//迭代器内部类
//当不断调用next()该方法时 元素就一个接一个呗读取出来了
private final class ValueIterator extends HashIterator<V> {
   public V next() {
       return nextEntry().value;
   }
}

具体在代码中的用法

//第一种
Collection<String> vs = m.values();
System.out.println(vs);
//第二种
Iterator<String> vs2 = m.values().iterator();
while(vs2.hasNext()){
	System.out.println(vs2.next());
}

2.键遍历（keySet）

迭代方式和值遍历略有不同本质上还是使用HashIterator来迭代。只不过由取value变成了取key

public Set<K> keySet() {
   Set<K> ks = keySet;
   return (ks != null ? ks : (keySet = new KeySet()));
}

private final class KeySet extends AbstractSet<K> {
   public Iterator<K> iterator() {
       return newKeyIterator();
   }
   public int size() {
       return size;
   }
   public boolean contains(Object o) {
       return containsKey(o);
   }
   public boolean remove(Object o) {
       return HashMap.this.removeEntryForKey(o) != null;
   }
   public void clear() {
       HashMap.this.clear();
   }
}

Iterator<K> newKeyIterator()   {
   return new KeyIterator();
}
private final class KeyIterator extends HashIterator<K> {
    public K next() {
        return nextEntry().getKey();
    }
}

实际迭代用法,雷同与值遍历

Set<String> keys = m.keySet();
System.out.println(keys);
Iterator<String> keys2 = m.keySet().iterator();
while (keys2.hasNext()) {
	System.out.println(keys2.next());
}

3.键值对遍历（entrySet）

迭代方式相同此处就不在赘述。

public Set<Map.Entry<K,V>> entrySet() {
   return entrySet0();
}

private Set<Map.Entry<K,V>> entrySet0() {
    Set<Map.Entry<K,V>> es = entrySet;
    return es != null ? es : (entrySet = new EntrySet());
}

private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public Iterator<Map.Entry<K,V>> iterator() {
        return newEntryIterator();
    }
    public boolean contains(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry<K,V> e = (Map.Entry<K,V>) o;
        Entry<K,V> candidate = getEntry(e.getKey());
        return candidate != null && candidate.equals(e);
    }
    public boolean remove(Object o) {
        return removeMapping(o) != null;
    }
    public int size() {
        return size;
    }
    public void clear() {
        HashMap.this.clear();
    }
}

Iterator<Map.Entry<K,V>> newEntryIterator()   {
    return new EntryIterator();
}

private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
    public Map.Entry<K,V> next() {
        return nextEntry();
    }
}

用法和上面两个并无差别

Set<Entry<String, String>> es = m.entrySet();
System.out.println(es);
Iterator<Map.Entry<String, String>> it = m.entrySet().iterator();
while (it.hasNext()) {
	System.out.println(it.next());
}

3.HashMap的问题

HashMap的线程安全问题一直为人所诟病，幸好我们有了Hashtable、ConcurrentHashMap等安全的hashmap。

4.总结

1. 允许以Key为null的形式存储<null,Value>键值对。

2. HashMap的查找效率非常高，因为它使用Hash表对进行查找，可直接定位到Key值所在的链表中；

3. 使用HashMap时，要注意HashMap容量和加载因子的关系，这将直接影响到HashMap的性能问题。加载因子过小，会提高HashMap的查找效率，但同时也消耗了大量的内存空间，加载因子过大，节省了空间，但是会导致HashMap的查找效率降低。需要使用接从中权衡利弊。