HashMap源码分析-jdk1.7

注:转载请注明出处!!!!!!!这里咱们看的是JDK1.7版本的HashMap

学习HashMap前先知道熟悉运算符合

 *左移 << ：就是该数对应二进制码整体左移，左边超出的部分舍弃，右边补零。举个例子：253的二进制码1111 1101，在经过运算253<<2后得到1111 0100。很简单  

*右移 >> ：该数对应的二进制码整体右移，左边的用原有标志位补充，右边超出的部分舍弃。

*无符号右移 >>> ：不管正负标志位为0还是1，将该数的二进制码整体右移，左边部分总是以0填充，右边部分舍弃。

*取模运算 h & (length-1) 就是 h%lenght ,但是&比%具有更高的效率

总结下 X>>Y  相当于X/(2^Y)  X<<Y 相当于X*(2^Y)

知道了运算后,先看创建HashMap的4个构造方法

/**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and load factor.
     *
     * @param  initialCapacity the initial capacity
     * @param  loadFactor      the load factor
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */

    //初始化HashMap,使用传入的初始容量和加载因子
    public HashMap(int initialCapacity, float loadFactor) {
        //初始容量不能小于0否则抛异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        //如果自定义的初始容量大于默认的最大容量(1<<30=2^30)则将默认     
        //最大容量赋值给传入的初始容量
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //如果加载因子小于等于0或者加载因子不是一数字,抛异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        //当前加载因子=传入加载因子
        this.loadFactor = loadFactor;
        //扩容变量 = 传入初始容量
        threshold = initialCapacity;
        //初始化
        init();
    }

/**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and the default load factor (0.75).
     *
     * @param  initialCapacity the initial capacity.
     * @throws IllegalArgumentException if the initial capacity is negative.
     */

    //初始化HashMap传入一个自定义的初始容量,默认的加载因子(0.75)
    public HashMap(int initialCapacity) {
        //走上面的初始化方法
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
     //初始化HashMap,使用默认的初始容量(1<<4= 2^4 =16)
     //和默认的加载因子(0.75)
    public HashMap() {
       //同上
       this(DEFAULT_INITIAL_CAPACITY,DEFAULT_LOAD_FACTOR);
    }

 

    /**
     * Constructs a new <tt>HashMap</tt> with the same mappings as the
     * specified <tt>Map</tt>.  The <tt>HashMap</tt> is created with
     * default load factor (0.75) and an initial capacity sufficient to
     * hold the mappings in the specified <tt>Map</tt>.
     *
     * @param   m the map whose mappings are to be placed in this map
     * @throws  NullPointerException if the specified map is null
     */
    
    //构造一个映射关系与指定 Map 相同的新 HashMap
    public HashMap(Map<? extends K, ? extends V> m) {
        //调用自己的构造,取出最大初始容量,默认加载因子
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        //创建一个Entry[],初始化Hash掩饰码
        inflateTable(threshold);
        //将m的值put到新的HashMap中或者创建一个新的HashMap
        putAllForCreate(m);
    }

 以上是HashMap的4种构造方法,下面我们来一步步分析源码

/**
     * The default initial capacity - MUST be a power of two.
     */
    //HashMap的默认初始化容量  2^4 = 16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    //HashMap的默认最大容量  2^30 = 1073741824
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.
     */
    //HashMap的默认加载因子 
    //(注:当前容量 >= 最大容量 * 0.75 时会进行扩容)
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * An empty table instance to share when the table is not inflated.
     */
    //一个空的Entry[] 哈希表
    static final Entry<?,?>[] EMPTY_TABLE = {};

    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    //(transient:表示不进行序列化)将上面的Entry赋值过来,始终未2的幂
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

    /**
     * The number of key-value mappings contained in this map.
     */
    // 表示HashMap的键值映射数目,已存元素个数
    transient int size;

    /**
     * The next size value at which to resize (capacity * load factor).
     * @serial
     */
    // If table == EMPTY_TABLE then this is the initial capacity at which the
    // table will be created when inflated.
    //扩容变量  size>=threshold 时就会扩容
    int threshold;

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
    //加载因子
    final float loadFactor;

    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     */
    //修改次数
    transient int modCount;

    /**
     * The default threshold of map capacity above which alternative hashing is
     * used for String keys. Alternative hashing reduces the incidence of
     * collisions due to weak hash code calculation for String keys.
     * <p/>
     * This value may be overridden by defining the system property
     * {@code jdk.map.althashing.threshold}. A property value of {@code 1}
     * forces alternative hashing to be used at all times whereas
     * {@code -1} value ensures that alternative hashing is never used.
     */
    //这个常量在静态类部类中Holder使用过,可能影响初始化hash掩饰码
    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;

以上HashMap的参数解释,下面看看我们最常用的 put(K,V) 和 get(K)

先来看看put(K,V)

 /**
     * Associates the specified value with the specified key in this map.
     * If the map previously contained a mapping for the key, the old
     * value is replaced.
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @return the previous value associated with <tt>key</tt>, or
     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
     *         (A <tt>null</tt> return can also indicate that the map
     *         previously associated <tt>null</tt> with <tt>key</tt>.)
     */

    //这里put 会返回 value 一般情况来说为空,发送冲突后value会返回发生冲突前的值
    public V put(K key, V value) {
        //根据上面的参数解释可以得到结果 第一次为true
        if (table == EMPTY_TABLE) {
            //第一次put会新建一个Entry[]赋值给table,初始化table的大小 2的幂
            inflateTable(threshold);
        }
        //map的key可以为空就是在这
        if (key == null)
            //key为null都会将value存放在table[0]中
            //第一次加入时:修改次数+1,元素数量+1
            //如果有冲突则返回老值
            //这里也会进行容量判断如果当前容量大于等于默认容量则扩容
            //扩容为table.length*2 具体扩容放在后面解释
            return putForNullKey(value);
        //生成当前key的哈希值
        int hash = hash(key);
        //生成一个下标
        int i = indexFor(hash, table.length);
        //这里看当前下标中table是否有值
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
             //如果有值则判断 hash值和当前生成的hash值是否相同且当前的key和Entry里面的key是否相同
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                //如果相同
                //将以前的value 赋值给 oldValue这个局部变量
                V oldValue = e.value;
                //当前的value赋盖原本已有值的value
                e.value = value;
                //一个空的预留方法,可以重写
                e.recordAccess(this);
                //返回老值
                return oldValue;
            }
        }
        //如果没有相同的key则修改次数+1
        modCount++;
        //将当前元素加入到新的Entry里面,存入table[i]中,元素数量+1
        addEntry(hash, key, value, i);
        //如果是一个新key都会返回null
        return null;
    }

解读put(K,V)中 putForNullKey(value) , indexFor(hash,table.length)  , addEntry(hash,key,value,i)

/**
     * Offloaded version of put for null keys
     */
    //put的key为NULL
    private V putForNullKey(V value) {
        //先去查找table[0]中是否有值
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            //table[0]中的Entry key 为null 时
            if (e.key == null) {
                //这里和put里面的处理重复key,覆盖value
                //将当前值赋值给一个局部变量
                V oldValue = e.value;
                //新的值覆盖老的值
                e.value = value;
                //空方法
                e.recordAccess(this);
                //返回以前的值
                return oldValue;
            }
        }
        //如果table[0]没有元素时 修改次数+1
        modCount++;
        //新建一个Entry将它放入table[0]中
        addEntry(0, null, value, 0);
        //返回null
        return null;
    }

 /**
     * A randomizing value associated with this instance that is applied to
     * hash code of keys to make hash collisions harder to find. If 0 then
     * alternative hashing is disabled.
     */
    //hash种子
    transient int hashSeed = 0;

 /**
     * Retrieve object hash code and applies a supplemental hash function to the
     * result hash, which defends against poor quality hash functions.  This is
     * critical because HashMap uses power-of-two length hash tables, that
     * otherwise encounter collisions for hashCodes that do not differ
     * in lower bits. Note: Null keys always map to hash 0, thus index 0.
     */
    //生成哈希码
    final int hash(Object k) {
        //hash种子,在第一次put的时候会生成一次 下面的算法有兴趣的可以看看
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }




 /**
     * Returns index for hash code h.
     */
    //根据hash值和table的容量计算出一个下标
    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }


 /**
     * Adds a new entry with the specified key, value and hash code to
     * the specified bucket.  It is the responsibility of this
     * method to resize the table if appropriate.
     *
     * Subclass overrides this to alter the behavior of put method.
     */
    //这里比较关键了,细心的朋友可能看到了当key为空的时候传入进来的值
    //(0,null,value,0)
    void addEntry(int hash, K key, V value, int bucketIndex) {
        //如果元素个数>=容量 且 当前出现碰撞
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //扩容
            resize(2 * table.length);
            //如果当前key不为null则hash(key) 否则 hash为0,这里和上面key为0时hash保持一致
            hash = (null != key) ? hash(key) : 0;
            //获取一个下标覆盖原有下标
            bucketIndex = indexFor(hash, table.length);
        }
        //创建一个Entry存入table[bucketIndex]中,元素+1
        createEntry(hash, key, value, bucketIndex);
    }




 /**
     * Like addEntry except that this version is used when creating entries
     * as part of Map construction or "pseudo-construction" (cloning,
     * deserialization).  This version needn't worry about resizing the table.
     *
     * Subclass overrides this to alter the behavior of HashMap(Map),
     * clone, and readObject.
     */
    //创建一个Entry
    void createEntry(int hash, K key, V value, int bucketIndex) {
        //这里会将当前下标(bucketIndex)的table里的值放入局部类e中
        //这里的操作是为了解决碰撞具体往下面看new Entry
        Entry<K,V> e = table[bucketIndex];
        //创建一个新的Entry放入当前下标中
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        //元素+1
        size++;
    }

//一个静态的内部类 实现了 map.Entry接口
//这里只解释下碰撞处理过程,具体里面的内部类方法有兴趣可以自己看下很简单
 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

        /**
         * Creates new entry.
         */
        //上面我们看到new实现了4个参数的构造,里面接收了一个局部类是做什么用的呢我们往下看
        Entry(int h, K k, V v, Entry<K,V> n) {
            //将新的value赋值给当前类的value
            value = v;
            //划重点----------------------------------
            //这里是老的entry赋值给新的entry的next
            //所以从这里我们可以得出key的hash发生冲突后不能说覆盖以前的值
            //以前的值要想获取就在新的值的next里面
            //他们的hash相同key不相同所以在上面源码我们可以发现只有当hash相同时才会进行碰撞处理
            //因为下标是 hash 和 表容量 计算出来的
            //注:没有发生碰撞时next为null
            next = n;
            //新的key
            key = k;
            //新的hash值
            hash = h;
        }

}

以上就是put需要执行的一些动作

下面咱们进入扩容方法 resize(2*table.length)

//扩容传入一个新的容量
void resize(int newCapacity) {
        //将当前table放入一个局部数组变量中
        Entry[] oldTable = table;
        //获得当前table的大小
        int oldCapacity = oldTable.length;
        //如果当前容量为1<<30=2^30 时
        if (oldCapacity == MAXIMUM_CAPACITY) {
            //当前的扩容因子大小赋值为2^31-1
            threshold = Integer.MAX_VALUE;
            //高并发的时候会进入,隐患
            //划重点---------------------
            //如果一直高并发会出大问题,譬如数组越界
            return;
        }
        //创建一个新的table,容量为2*table.length 记住一定是2倍
        Entry[] newTable = new Entry[newCapacity];
        //创建一个新的hash种子,将以前的值放入newTable中
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        //扩容后的table覆盖现在的table
        //来,这里有个坑,划重点--------------
        //如果现在很多线程在get 这里会怎样?
        //对应的value全为null
        table = newTable;
        //将扩容因子赋值为倆数中小的那一个
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }



//老的数据迁移到新table里面
 void transfer(Entry[] newTable, boolean rehash) {
        //新的表的容量赋值给一个局部变量
        int newCapacity = newTable.length;
        //循环以前的table,这里还没进行赋值所以table是以前的数据
        for (Entry<K,V> e : table) {
            while(null != e) {
                //将entry里面的next赋值给局部类
                Entry<K,V> next = e.next;
                if (rehash) {
                    //如果是新的hash种子,生成新的hash值
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                //获取一个新的table的index
                int i = indexFor(e.hash, newCapacity);
                //将当前index下的table赋值给当前entry.next
                e.next = newTable[i];
                //将当前老table中的数据放入新table当前下标中
                newTable[i] = e;
                //将局部变量的值赋值给局部变量e
                //while循环依据,主要是保存碰撞元素中next的值
                //这里建议写自己个例子帮助理解,仿Entry类就好
                e = next;
            }
        }
    }

至此put(K,V)结束了,扩容也一并在里面讲解了

梳理一下:

　　1.第一次put值的时候初始化表空间

　　2.key为空的时候会加入

　　3.会根据key生成哈希值

　　4.如果发生碰撞(hash值相等)的时候,会将新的值存放在新的entry里,老的值会存放在新值的entry.next里

　　5.正常情况下 修改次数+1,元素数量+1,新建一个Entry放入table[bucketIndex]中

　　6.bucketIndex是根据hash值和当前table长度计算出来的

　　7.如果遇到扩容,新容器是旧容器的2倍,新的容器将重新生成hash种子,老元素会赋值到新容器中,注意:高并发的时候取值可能为null,严重时会出现数组越界,死循环的问题,所以HashMap是线程不安全的

下面咱们看看get(K)

 
//根据key获取value
public V get(Object key) {
        //如果key为null,则去table[0]上的值
        if (key == null)
            return getForNullKey();
        //根据key获取value
        Entry<K,V> entry = getEntry(key);
        //如果entry不为null则返回当前entry的value
        return null == entry ? null : entry.getValue();
    }

//获取key为null的value
 private V getForNullKey() {
        //判断元素个数为0返回null
        if (size == 0) {
            return null;
        }
        //如果table[0]上有元素则返回当前table[0]的value
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        //否则返回null
        return null;
    }


//key不为null时
final Entry<K,V> getEntry(Object key) {
        //判断元素个数为0返回null
        if (size == 0) {
            return null;
        }
        //根据key获取hash值
        int hash = (key == null) ? 0 : hash(key);
        //通过hash和table容量取出下标获取当前下标table的entry
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            //如果hash值和key都相等则返回对应的entry
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        //否则返回空
        return null;
    }

get相对来说就简单很多了!

咱们来继续来看看remove操作

//移除key对应table[]中的entry
public V remove(Object key) {
        //移除key对应table[]中的entry
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

//移除key对应table[]中的entry
final Entry<K,V> removeEntryForKey(Object key) {
        //元素个数为0返回null
        if (size == 0) {
            return null;
        }
        //判断hash是否为null
        int hash = (key == null) ? 0 : hash(key);
        //生成table的index
        int i = indexFor(hash, table.length);
        //将当前下标的entry放在局部变量中
        Entry<K,V> prev = table[i];
        //局部变量pre赋值给局部变量e
        Entry<K,V> e = prev;
        //如果当前元素不为空
        while (e != null) {
            //先取出当前元素的next
            Entry<K,V> next = e.next;
            Object k;
            //判断hash值和key是否相等,注意碰撞只是hash值相同key不同
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                //相等修改次数+1
                modCount++;
                //元素-1
                size--;
                //一般情况下两个内存地址是相等的
                if (prev == e)
                    //将next的值覆盖当前下标的值,没有碰撞时这时候table[i]当前值为null
                    table[i] = next;
                else
                    //碰撞情况下将next的值覆盖pre.next也就是说这时候prev是有值的,移除的只是相同hashcode但key不同的碰撞体
                    prev.next = next;
                //空方法
                e.recordRemoval(this);
                //返回移除的entry
                return e;
            }
            //我们上面知道了碰撞后旧值在新值的next中所以这一段理解就是如果当前下标中有碰撞存在那么将e赋值给prev
            prev = e;
            //e等于当前e.next,如果不为空则继续进行移除
            e = next;
        }
        //e为null直接返回
        return e;
    }

清除HashMap

//清除hashmap 
public void clear() {
        //修改+1
        modCount++;
        //循环table将每个下标对应的值都替换成null
        Arrays.fill(table, null);
        //元素个数归零
        size = 0;
    }
//循环table将每个下标对应的值都替换成null
 public static void fill(Object[] a, Object val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }

我们注意到主要传入key那么就一定会进行hash然后通过hash和表容量计算出对应table的index也可以说bucketIndex.这个流程一定要注意

以上就是基本的HashMap源码解读了,有讲解不清楚,容易混淆的文字或者错误的地方欢迎指出.