hashMap源码分析

1、hashMap基于数组和链表的，那么如何对hashMap进行扩容呢？，这里需要进行二次判断是不是超过阈值了，如果超过阈值则需要对hashMap进行扩容。

2、hashMap的容量为hashMap中桶的数量，即数组的大小。

3、hashMap的size为hashMap中键值对的个数，即kv键值对的个数。

4、hashMap的实现，看put和get源码，最主要的也是这个两个函数的实现，本源码是基于jdk1.7的源码实现。

• 首先来看看put的源代码：

public V put(K key, V value) {
    //如果为空，则默认给值
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
   //允许key为空
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
//拿到当前的容器的下标
    int i = indexFor(hash, table.length);
    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++;
//否则就添加到新的table数组当中
    addEntry(hash, key, value, i);
    return null;

再来看看addEntry的代码是如何解析的？

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);   //扩容为原来的2倍
        hash = (null != key) ? hash(key) : 0;//得到hash值
        bucketIndex = indexFor(hash, table.length); //得到数组的位置
    }

    createEntry(hash, key, value, bucketIndex); //创建一个entry
}

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); //重新给一个阈值
}

其中有一个transfer函数写的非常巧妙：

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

每次遍历旧的table的链表，在重新计算每个链表值在容器中的位置，最后将值给到数组的第一个位置，即链表的头（和插入时的用法是一样的，都是插入链表的头，这段很精彩）。

再来看看createEntry的源码：

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

可以看到每次都是将最新添加的元素放在链表的第一个元素位置，也就是table中的第一个元素。

• 接着分析get源码是如何获得数据的：

  public V get(Object key) {
      if (key == null)
          return getForNullKey();
      Entry<K,V> entry = getEntry(key);
  
      return null == entry ? null : entry.getValue();
  }

主要是看getEntry的代码

final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }

    int hash = (key == null) ? 0 : hash(key);  //如果key为空的话hash为0
    for (Entry<K,V> e = table[indexFor(hash, table.length)];  //拿到当前table为0的数组的链表
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

从get和put可以分析得出HashMap是线程不安全的，没有加锁处理机制，如果多个线程访问同一个Map会造成数据不正确的问题，如果在多线程环境下，采用ConcurrentHashMap可以解决线程不安全的问题。