HashMap源码分析jdk1.7

jdk1.7的hashmap是根据数组+链表的方式进行存储的。

数组下标是根据计算的hash值和数组长度算出来的（防止越界）。

链表存储的方式是头插法。

下面是我整理出的put时的流程图：

hashmap的重要属性：

//1. HashMap的K, v的值,在创建对象的时候确定: K: Integer V:String
//HashMap的父类AbstractMap已经实现类Map接口,但是源码中又单独实现了Map接口
//这个操作就是-一个多余的操作-->集合的创作者 承认了
public class HashMap<K,V> extends AbstractMap<K,V>
	implements Map<K,V>, Cloneable, Serializable {
//默认初始化化容量,即16  
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

//最大容量，即2的30次方  
static final int MAXIMUM_CAPACITY = 1 << 30;  

//默认加载因子  
static final float DEFAULT_LOAD_FACTOR = 0.75f;  

//HashMap内部的存储结构是一个数组，此处数组为空，即没有初始化之前的状态  
static final Entry<?,?>[] EMPTY_TABLE = {};  

//空的存储实体  
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;  

//HashMap的元素数目  
transient int size;  

//HashMap下次扩容是的阀值，threshold = 初始容量 * 加载因子
int threshold;  

//HashMap的加载因子  
final float loadFactor;  

//修改次数  
transient int modCount;  

//最大的扩容阈值
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;

//hash总值，默认为0，目的使hash更复杂，结果更散列 
transient int hashSeed = 0;  

构造方法：

//容量取16，加载因子取0.75，构造HashMap  
public HashMap() {  
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);  
} 

//通过加载因子构造HashMap,容量取默认值，即16  
public HashMap(int initialCapacity) {  
    this(initialCapacity, DEFAULT_LOAD_FACTOR);  
} 
  
//通过初始容量和加载因子构造HashMap  
public HashMap(int initialCapacity, float loadFactor) {  
    if (initialCapacity < 0)//初始容量不能小于0
        throw new IllegalArgumentException("Illegal initial capacity: " +  
                                           initialCapacity);  
    if (initialCapacity > MAXIMUM_CAPACITY)//最大容量不能大于2的30次方 
        initialCapacity = MAXIMUM_CAPACITY;  
    if (loadFactor <= 0 || Float.isNaN(loadFactor))//加载因子必须为数字，并且不能小于0
        throw new IllegalArgumentException("Illegal load factor: " +  
                                           loadFactor);  

    this.loadFactor = loadFactor;  
    threshold = initialCapacity;  
    init();//这个实现为空，LinkedHashMap会使用 
} 

//通过其他Map来初始化HashMap,容量通过其他Map的size来计算，装载因子取0.75  
public HashMap(Map<? extends K, ? extends V> m) {  
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,  
                  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);  
    inflateTable(threshold);//初始化HashMap底层的数组结构  
    putAllForCreate(m);//添加m中的元素  
} 

初始化HashMap方法：选取初始加载容量为：大于等于传入容量的2的幂次方。比如传入容量为6，那么实际初始化容量为8。

//初始化HashMap的底层数据结构  
private void inflateTable(int toSize) {
    int capacity = roundUpToPowerOf2(toSize);//选取合适的容量值
    
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//选取合适的threshold（扩容阀值）
    table = new Entry[capacity];//初始化底层数据结构
    initHashSeedAsNeeded(capacity);//选择合适的Hash总值，这里和虚拟机的配置有关
}  

//选择合适的容量值，容量值取大于等于最接近number的2的冪数  
private static int roundUpToPowerOf2(int number) {
    // 如果传入容量超出了最大值，则采用最大值。如果小于1，则容量使用1
    // 其余情况：容量 <= 最接近容量的2的幂数，比如 容量 10=>16,  16=>16
    /*
    * 假设传入值为10：
    *   首先，计算(number - 1) << 1，也就是(10-1) << 1 = 18，number - 1是为了防止特殊情况，比如number = 16
    *   然后调用Integer.highestOneBit(18)，最终返回为16.
    *        二进制                十进制
    *       0001 0010               18
    *       0001 1111               31          首先，将最高位之后所有位转换为1
    *       0000 1111               15          右移一位之后，相减也就是 （11111）2 - （1111）2 => 31 - 15 = 16
    *       ----------------------------
    *       0000 1111               16
    * */
    return number >= MAXIMUM_CAPACITY  ?
            MAXIMUM_CAPACITY  : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}  

hash的计算方式：

//计算key的Hash值，这里针对String类的Key优化了Hash函数
final int hash(Object k) {  
    int h = hashSeed;  //hash总值，初始值为0
    if (0 != h && k instanceof String) {//这里针对String优化了Hash函数，是否使用新的Hash函数和Hash因子有关  
        return sun.misc.Hashing.stringHash32((String) k);  
    }  
    /*
    * 这里将获取到的hashCode值>>>和^，是为了更好的平均分配定位hash桶位置索引，让高位的二进制数参与到定位hash桶位置的运算中。
    * */
    h ^= k.hashCode();  
    h ^= (h >>> 20) ^ (h >>> 12);  
    return h ^ (h >>> 7) ^ (h >>> 4);  
}  

使用下面的方法计算放在数组的下标位置，为了防止根据hash值计算出来的下标越界：

//根据Hash值和Hash表的大小选择合适的Hash桶  
static int indexFor(int h, int length) {
    /*
    * 返回需要保证两个条件：
    *       1.返回值小于length
    *       2.分配平均
    * 假设hash为17，传入容量为10，经过计算之后的容量为16，那么返回值就为 17 & (16 - 1)
    *       二进制             十进制
    *       0001 0001           17
    *       0000 1111           15
    *   &
    * -----------------------------
    *       0000 0001           1
    * */
    return h & (length-1);  
}

put方法
如果底层数组为空，则会先初始化底层数组，默认容量为16。定位Hash桶位置，并且遍历该链表下的所有节点，如果有节点和插入节点的key相同，就覆盖该节点，并且返回旧的value，如果没有key相同，那么就会采用头插法，将该节点插入。
如果key为空，则执行空的逻辑，说明HashMap可以存放key为null的元素，该元素默认存放在数组下标为0的链表中。
 

//添加元素  
public V put(K key, V value) {  
    if (table == EMPTY_TABLE) {//具体看：容量计算方法
        inflateTable(threshold);
    }  
    if (key == null)//如果key为空，则执行空的逻辑，说明HashMap可以存放key为null的元素
        return putForNullKey(value);  
    int hash = hash(key);//获取key的Hash值  
    int i = indexFor(hash, table.length);//定位Hash桶  
    //如果放入的数组的位置上没有元素的话，那么直接添加就行了,不用走这个for循环
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {//定位到hash桶的链表上，是否有key相同的元素，如果有返回并修改旧值
        Object k;
        //发生哈西碰撞的时候,会先比较哈希值
		//比较key是否是一一个对象，如果key是一-个对象的话,equals就不比较了
		//如果不是同一个对象,会比较equals方法
		//如果hash值- -样，equals方法比较的结果也一-样，那么才会走这个if方法:
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {//hash相同，并且key相同
            V oldValue = e.value;  //获取老的value
            e.value = value;//新值覆盖旧值-->只替换value不替换key
            e.recordAccess(this);//调用value的回调函数，其实这个函数也为空实现  
            return oldValue;//返回旧值
        }  
    }  

    modCount++;//更新修改次数  
    addEntry(hash, key, value, i);//添加到对应Hash桶的链接表中，头插法
    return null; //如果该key以前没有被添加过，则返回null
} 

addEntry()添加新元素:

void addEntry(int hash, K key, V value, int bucketIndex) {
      // 当数组的size >= 扩容阈值，触发扩容，size大小会在createEnty和removeEntry的时候改变
      if ((size >= threshold) && (null != table[bucketIndex])) {
          // 扩容到2倍大小，后边会跟进这个方法
          resize(2 * table.length);
          // 扩容后重新计算hash和index
          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<K,V> e = table[bucketIndex];
              table[bucketIndex] = new Entry<>(hash, key, value, e);
              size++;   //标记table数组中已存储key-val的个数，为了判断是否需要扩容
        
  }

hash的扩容：

//执行扩容
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));//将老的数据拷贝到新的结构中。initHashSeedAsNeeded为是否使用hash总值，与虚拟机配置有关，默认为false
    table = newTable;//修改HashMap的底层数组  
    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);//定位Hash桶，计算的结果可能为：初始位置 或者 初始位置 + 扩容量
            e.next = newTable[i];//扩容插入也会采用头插法，与旧的hash桶相比链表的顺序可能会被颠倒，并且分散到 初始位置 和 初始位置 + 扩容量两个位置中
            newTable[i] = e;  
            e = next;  
        }  
    }  
} 

get方法：

public V get(Object key) {
        
        if (key == null)
            return getForNullKey();
        //获取Key为key的键值对
        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;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }
 
private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }