源码分析 - JDK 1.7

    1. //1. HashMap 的 K，V的值，在创建对象的时候确定，比如：K：Integer  V: String
    2. public class HashMap<K,V>
    3.     extends AbstractMap<K,V>
    4.     implements Map<K,V>, Cloneable, Serializable
    5. {
    7.     //重要属性：定义了一个16，赋给初始化数组长度
    8.     static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 
    10.     //定义了一个很大很大的数
    11.     static final int MAXIMUM_CAPACITY = 1 << 30;
    12.     //定义了加载因子，为 0.75
    13.     static final float DEFAULT_LOAD_FACTOR = 0.75f;
    15.     //定义空的主数组
    16.     static final Entry<?,?>[] EMPTY_TABLE = {};
    18.     //添加的元素的数量
    19.     transient int size;
    21.     //定义个变量，没赋值，为0 。 --- 这个变量用来表示数组扩容的边界值，
    22.     int threshold;
    24.     //加载因子，这个变量用来接收 加载因子的值
    25.     final float loadFactor;
    27. }

    构造器 

    1. //空构造器 
    2. public HashMap() {
    3.         //this.(16,0.75)
    4.         this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    5. }
    7. //有参的构造器,  16, 0.75   ---------》 不建议使用者调用这个构造器
    8. public HashMap(int initialCapacity, float loadFactor) {
    10.       if (loadFactor <= 0 || Float.isNaN(loadFactor))
    11.             throw new IllegalArgumentException("Illegal load factor: " +
    12.                                                loadFactor);
    13.         //确定了加载因子，0.75
    14.         this.loadFactor = loadFactor;
    15.         //扩展数组的边界值
    16.         threshold = initialCapacity;
    17.         init();
    18. }

    PUT方法

    1. public V put(K key, V value) {
    2.         if (table == EMPTY_TABLE) {
    3.             inflateTable(threshold);
    4.         }
    5.         if (key == null) // 对空值进行判断，允许key的值为空
    6.             return putForNullKey(value);
    7.         int hash = hash(key); // 获取hash码
    9.         int i = indexFor(hash, table.length);//得到元素在数组中的位置
    10.         // 通过放入的数组上，没有元素的话，那么直接添加元素，不走这个for循环。 
    12.         //如果e！= null 满足，就证明这个位置上有元素，
    13.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
    14.             Object k;
    15.             //发生哈希碰撞的时候，会先比较哈希值，
    16.             // 比较key是否是一个对象，如果是，equals就不比较了
    17.             //  比较key是否是一个对象，如果不是，则比较equals
    18.             // 如果hash值一样，equals方法比较的结果也一样，那么才会走这个方法
    19.             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
    20.                 V oldValue = e.value;
    21.                 e.value = value;// 新value 替换 老 value，  只替换value，不替换value
    22.                 e.recordAccess(this);
    23.                 return oldValue;// 将old 的value返回，即原始的value值
    24.             }
    25.         }
    27.         addEntry(hash, key, value, i);
    28.         return null;
    29.     }
    31. // 获取Key 的 hashcode 的方法
    32. final int hash(Object k) {
    33.         int h = hashSeed;
    34.         if (0 != h && k instanceof String) {
    35.             return sun.misc.Hashing.stringHash32((String) k);
    36.         }
    37.         //进行了二次散列，没有直接用hashcode的值性，减少冲突
    38.         h ^= k.hashCode();
    40.         //扰动函数，核心思想：增加hashcode的不确定
    41.         h ^= (h >>> 20) ^ (h >>> 12);
    42.         return h ^ (h >>> 7) ^ (h >>> 4);
    43. }
    46. static int indexFor(int h, int length) {
    47.     // 计算位置对应的公示，等效于  h % length取余数，因为这样效率高
    48.    return h & (length-1);
    49. }
    51. //添加元素的方法
    52. void addEntry(int hash, K key, V value, int bucketIndex) {
    53.     //如果这个size 》=  threshold ，这个if不走了
    54.     if ((size >= threshold) && (null != table[bucketIndex])) {
    55.         resize(2 * table.length);
    56.         hash = (null != key) ? hash(key) : 0;
    57.         bucketIndex = indexFor(hash, table.length);
    58.     }
    59.     //创建一个Entry对象
    60.     createEntry(hash, key, value, bucketIndex);
    61. }
    63. //创建一个Entry对象
    64. void createEntry(int hash, K key, V value, int bucketIndex) {
    65.     //将下标位置上的元素给e
    66.     Entry<K,V> e = table[bucketIndex];
    67.     //封装对象，将这个对象给table[bucketIndex]   -----------》 链表的《头插法》
    68.     table[bucketIndex] = new Entry<>(hash, key, value, e);
    69.     //元素数量+1
    70.     size++;
    71. }

    扩容resize

    1. //添加元素的方法
    2. void addEntry(int hash, K key, V value, int bucketIndex) {
    3.     //如果这个size 》=  threshold ，这个if不走了
    4.     if ((size >= threshold) && (null != table[bucketIndex])) { // 如果size 大于 12(16*0.75) 并且 该位置有元素了，才会去扩容
    5.         resize(2 * table.length); // 扩容大为2倍
    6.         hash = (null != key) ? hash(key) : 0;
    7.         bucketIndex = indexFor(hash, table.length);
    8.     }
    9.     //创建一个Entry对象
    10.     createEntry(hash, key, value, bucketIndex);
    11. }
    13.     void resize(int newCapacity) {
    14.         Entry[] oldTable = table;
    15.         int oldCapacity = oldTable.length;
    16.         if (oldCapacity == MAXIMUM_CAPACITY) {
    17.             threshold = Integer.MAX_VALUE;
    18.             return;
    19.         }
    21.         Entry[] newTable = new Entry[newCapacity];
    22.         transfer(newTable, initHashSeedAsNeeded(newCapacity)); // transfer 将新数组给老数组
    23.         table = newTable;
    24.         threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    25.     }