HashMap源码分析 基于JDK1.6

public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable, Serializable {    static final int DEFAULT_INITIAL_CAPACITY = 16; //系统默认初始容量    static final int MAXIMUM_CAPACITY = 1 << 30; //系统默认最大容量    static final float DEFAULT_LOAD_FACTOR = 0.75f; //系统默认初始加载因子    transient Entry[] table; //用于存储的表    transient int size; //当前map中key-value映射数    int threshold; //当前阈值    final float loadFactor; //哈希表加载因子    transient volatile int modCount; //确保使用迭代器时，HashMap并未更改    /*---------------------------------构造函数----------------------------------------*/    /**     * 默认构造函数     * 构造一个初始容量为16和默认加载因子为0.75的空的HashMap     */    public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR;//哈希表加载因子为默认加载因子        this.threshold = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);//设置阈值12 = 16 * 0.75，当HashMap的size达到此阈值时，HashMap就该扩容        table = new Entry[DEFAULT_INITIAL_CAPACITY];//创建一个默认容量16的空数组        init();    }    /**     * 带指定初始容量和指定加载因子的构造函数     * 构造一个带指定初始容量和指定加载因子的空的HashMap     */    public HashMap(int initialCapacity, float loadFactor) {        //指定初始容量小于0 抛错        if (initialCapacity < 0)            throw new IllegalArgumentException("Illeagal initial capacity : " + initialCapacity);        //指定初始容量大于系统最大容量，则初始容量为最大容量        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        //加载因子小于0或为naN 抛错        if (loadFactor < 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);        //寻找一个2的k次幂capacity恰好大于initialCapacity        int capacity = 1;        while (capacity < initialCapacity) {            capacity <<= 1;        }        //设置哈希表的加载因子为指定的加载因子        this.loadFactor = loadFactor;        //设置阈值        this.threshold = (int) (capacity * loadFactor);        //创建一个capacity长度的数组用于保存数据        table = new Entry[capacity];        //开始初始化        init();    }    /**     * 带指定初始容量的构造函数     * 构造一个带有指定初始容量和默认加载因子0.75的空的HashMap     */    public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }    /**     * 带指定映射关系的狗构造函数     * 构造一个映射关系与指定的map相同的HashMap     */    public HashMap(HashMap<? extends K, ? extends V> m) {        //调用带指定容量和默认加载因子的构造函数 容量为指定map的容量与默认初始容量中较大者        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,                DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);        putAllForCreate(m);    }    /*----------------------------------方法区------------------------------------*/    //定义一个空方法用于对未来子对象的扩展  该方法用于初始化之后  插入元素之前    public void init() {    }    /**     * 方法:二次hash计算     * 预处理hash值,对key的hashCode进行二次hash计算,避免较差的离散hash序列,导致哈希桶没有充分利用     */    static int hash(int h) {        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);    }    /**     * 方法:返回hash值对应的索引     * 通过对hash值的计算,获取实际的存储位置     */    static int indexFor(int hash, int length) {        return hash & (length - 1);    }    /**     * 方法: 返回size     * 返回当前map的key-value映射数，也就是当前的size     */    public int size() {        return size;    }    /**     * 方法: 是否为空     * 判断HashMap是否为空 size为0时返回false     */    public boolean isEmpty() {        return size == 0;    }    /*------------------------------------核心方法区---------------------------------------------*/    /**     * 方法: 返回key对应value值     * 返回指定键(key)所映射的值(value),如果该键(key)不对应任何映射关系,返回null     */    public V get(Object key) {        //将key分为null,不为null的情况区别对待 此处就是HashMap能够存储(null,null)所做的处理        //如果key为null        if (key == null) {            return getForNullKey();        }        //如果key不为null        //对key的hashcode值进行二次hash计算预处理        int hash = hash(key.hashCode());        //根据hash值获取对应的桶 然后在桶内遍历查找        for (Entry<K, V> entry = table[indexFor(hash, table.length)]; entry != null; entry = entry.next) {            Object k = entry.key;            //如果hash值相等  并且key相等则证明这个桶内的东西是我们想要的            //hash值是根据key的hashcode进行复杂计算得到的,因此key相同的话hash一定相同,因此通过indexFor查找到的索引位置也一定相同            //但是索引位置相同,并不代表桶中的key对应hash值相同,因为不同hash值经过取膜计算后,会散到同同一索引位置的桶中            //因此先通过判断hash值是否相同,筛选掉不符合的entry,可以提高性能,因为equals方法效率很低            if (entry.hash == hash && (k == key || key.equals(k)))                return entry.value;        }        //桶内所有元素都找遍 没有找到key对应的value,代表该map中不存在该映射 因此返回null        return null;    }    /**     * 方法: 获取null对应value     * 如果key为null,通过该方法获取对应的value值     */    private V getForNullKey() {        //遍历table[0]桶内所有的元素 默认null对应的hash值所映射的索引位置为table[0]        for (Entry<K, V> entry = table[0]; entry != entry; entry = entry.next) {            if (entry.key == null)                return entry.value;        }        //没找到则返回null        return null;    }    /**     * 方法: 判断是否包含指定键对应映射关系     * 判断是否包含指定键的映射关系 存在返回true 不存在返回false     */    public boolean containsKey(Object key) {        return getEntry(key) != null;    }    /**     * 方法: 通过key获取value值     * 通过给定的key,求对应的value值,如果存在返回value  不存在 返回null     */    final Entry<K, V> getEntry(Object key) {        //获取hash值  key为null时 hash为0 不用进行二次hash计算        int hash = (key == null) ? 0 : hash(key.hashCode());        //得到对应hash值的桶        for (Entry<K, V> entry = table[indexFor(hash, table.length)]; entry != null; entry = entry.next) {            Object k;            //如果hash值相等,并且key相等,那么该value就是我们要找的            if (entry.hash == hash && ((k = entry.key) == key || (key != null && key.equals(k)))) {                return entry;            }        }        return null;    }    /**     * 方法: 在map中放置指定的键值对     * 在map中关联指定的值与指定的键 如果就得映射关系存在,则替换掉旧的value值     */    public V put(K key, V value) {        //如果key为null时用putForNullKey来专门存放        if (key == null)            return putForNullKey(value);        //获取对应的hash值        int hash = hash(key.hashCode());        //获取对应的索引值        int i = indexFor(hash, table.length);        //在对应的桶中遍历        for (Entry<K, V> entry = table[i]; entry != null; entry = entry.next) {            Object k;            //如果hash相同并且key相同            if (entry.hash == hash && ((k = entry.key) == key || key.equals(k))) {                //获取旧value                V oldValue = entry.value;                //替换旧的value                entry.value = value;                entry.recordAccess(this);                //返回旧value                return oldValue;            }        }        modCount++;        //在桶中没有找到对应key值,代表map中没有对应映射关系,因此就关联此映射关系        addEntry(hash, key, value, i);        return null;    }    /**     * 方法: 在map中放置key为null的键值对     */    private V putForNullKey(V value) {        //遍历table[0]的所有的桶        for (Entry<K, V> entry = table[0]; entry != null; entry = entry.next) {            //如果key为null            if (entry.key == null) {                //获取旧的value值                V oldValue = entry.value;                //替换新的value值                entry.value = value;                return oldValue;            }        }        modCount++;        //在桶中没有找到对应null值,代表map中没有对应映射关系,因此就关联此映射关系        addEntry(0, null, value, 0);        return null;    }    /**     * 方法: 判断是否创建新桶     */    private void putForCreate(K key, V value) {        //获取key对应的hash值        int hash = (key == null) ? 0 : hash(key.hashCode());        //获取hash值对应的索引值        int i = indexFor(hash, table.length);        //遍历桶        for (Entry<K, V> entry = table[i]; entry != null; entry = entry.next) {            Object k;            //如果有hash相同 且key相同 则不需要创建新桶            if (entry.hash == hash && ((k = entry.key) == key || (key != null && key.equals(k)))) {                return;            }        }        //否则就创建新的桶        createEntry(hash, key, value, i);    }    /**     * 方法: 根据map创建对应的桶     */    private void putAllForCreate(Map<? extends K, ? extends V> map) {        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = map.entrySet().iterator(); i.hasNext(); ) {            Map.Entry<? extends K, ? extends V> e = i.next();            putForCreate(e.getKey(), e.getValue());        }    }    /**     * 方法: 扩容     */    void resize(int newCapacity) {        //保存旧的table数组        Entry[] oldTable = table;        //保存旧数组的容量        int oldCapacity = oldTable.length;        //如果就容量已经达到系统默认最大容量 那么将阈值调整为整形最大值 然后退出        if (oldCapacity == MAXIMUM_CAPACITY) {            threshold = Integer.MAX_VALUE;            return;        }        //根据新容量创建一个新table数组        Entry[] newTable = new Entry[newCapacity];        //将table转换成newTable        transfer(newTable);        //将table设置为newTable        table = newTable;        //设置新的阈值为新容量 * 加载因子        threshold = (int) (newCapacity * loadFactor);    }    /**     * 方法: 将旧table转为新table     */    private void transfer(Entry[] newTable) {        //得到旧的table        Entry[] src = table;        //得到新的容量        int newCapacity = newTable.length;        //遍历旧的table: src中的所有桶        for (int j = 0; j < src.length; j++) {            //取出每一个桶            Entry<K, V> entry = src[j];            if (entry != null) {                src[j] = null;                do {                    Entry<K, V> next = entry.next;                    //在新的table中寻找新的索引                    int i = indexFor(entry.hash, newCapacity);                    //尾插法                    entry.next = newTable[i];                    newTable[i] = entry;                    entry = next;                } while (entry != null);            }        }    }    /**     * 方法: 将指定map中的映射复制到此map中     */    public void putAll(Map<? extends K, ? extends V> map) {        //需要复制的映射的数量        int numKeysToBeAdded = map.size();        if (numKeysToBeAdded == 0)            return;        //如果需要复制的映射关系大于当前map的阈值        if (numKeysToBeAdded > threshold) {            //重新计算当前map的容量            int targetCapacity = (int) (numKeysToBeAdded / loadFactor + 1);            if (targetCapacity > MAXIMUM_CAPACITY)                targetCapacity = MAXIMUM_CAPACITY;            //获取当前table数组的容量            int newCapacity = table.length;            while (newCapacity < targetCapacity)                newCapacity <<= 1;            if (newCapacity > table.length)                resize(newCapacity);        }        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = map.entrySet().iterator(); i.hasNext(); ) {            Map.Entry<? extends K, ? extends V> e = i.next();            put(e.getKey(), e.getValue());        }    }    /**     * 方法: 移除映射关系     * 从此映射中移除指定的映射关系 并返回移除映射的值     */    public V remove(Object key) {        Entry<K, V> entry = removeEntryForKey(key);        return (entry == null) ? null : entry.value;    }    /**     * 方法: 根据对应key删除对应的映射关系     */    final Entry<K, V> removeEntryForKey(Object key) {        int hash = (key == null) ? 0 : hash(key.hashCode());        int i = indexFor(hash, table.length);        //找到对应的桶        Entry<K, V> prev = table[i];        Entry<K, V> entry = prev;        //遍历该桶        while (entry != null) {            Entry<K, V> next = entry.next;            Object k;            if (entry.hash == hash && ((k = entry.key) == key || (key != null && key.equals(k)))) {                modCount++;                size--;                if (prev == entry)                    table[i] = next;                else                    prev.next = next;                return entry;            }            prev = entry;            entry = next;        }        return entry;//返回null    }    /**     * 方法: 根据key删除映射关系     */    final Entry<K, V> removeMapping(Object object) {        if (!(object instanceof Map.Entry))            return null;        //将object转为Map.Entry        Map.Entry<K, V> entry = (Map.Entry<K, V>) object;        //得到对应的key        Object key = entry.getKey();        //得到key对应的hash        int hash = (key == null) ? 0 : hash(key.hashCode());        int i = indexFor(hash, table.length);        Entry<K, V> prev = table[i];        Entry<K, V> e = prev;        while (e != null) {            Entry<K, V> next = e.next;            if (e.hash == hash && e.equals(entry)) {                modCount++;                size--;                if (prev == e)                    table[i] = next;                else                    prev.next = next;            }            prev = e;            e = next;        }        return e;    }    /**     * 方法: 移除所有映射关系     */    public void clear() {        modCount++;        Entry[] tab = table;        for (int i = 0; i < tab.length; i++)            tab[i] = null;        size = 0;    }    /**     * 方法: 判断是否存在指定的值对应的映射关系     * 如果存在一个或多个key映射指定value 返回true     */    public boolean containsValue(Object value) {        //如果value为null 调用专门的方法        if (value == null)            return containsNullValue();        Entry[] tab = table;        //遍历table数组        for (int i = 0; i < tab.length; i++)            for (Entry entry = tab[i]; entry != null; entry = entry.next)                if (value.equals(entry.value))                    return true;        return false;    }    /**     * 方法: 判断是否存在value为null的映射关系     */    private boolean containsNullValue() {        Entry[] tab = table;        for (int i = 0; i < tab.length; i++)            for (Entry entry = tab[i]; entry != null; entry = entry.next)                if (entry.value == null)                    return true;        return false;    }    /**     * 方法: 浅表拷贝     * 返回hashmap的浅表副本  不复制键和本身     */    public Object clone() {        HashMap<K, V> result = null;        try {            result = (HashMap<K, V>) super.clone();        } catch (CloneNotSupportedException e) {        }        result.table = new Entry[table.length];        result.modCount = 0;        result.size = 0;        result.init();        result.putAllForCreate(this);        return result;    }    /*--------------------------内置Class输入对象-------------------------------*/    static class Entry<K, V> implements Map.Entry<K, V> {        final K key;//键        V value;//值        Entry<K, V> next;//下一个节点        final int hash;        //构造函数        Entry(int h, K k, V v, Entry<K, V> n) {            value = v;            next = n;            key = k;            hash = h;        }        //返回key        public final K getKey() {            return key;        }        //返回value        public V getValue() {            return value;        }        //设置value  返回旧值        public final V setValue(V newValue) {            V oldValue = this.value;            this.value = newValue;            return oldValue;        }        //是否相同        @Override        public boolean equals(Object object) {            if (!(object instanceof Map.Entry))                return false;            //将object转化成Map.Entry            Map.Entry entry = (Map.Entry) object;            //比较key和value值            Object key1 = this.getKey();            Object key2 = entry.getKey();            if (key1 == key2 || key1 != null && key1.equals(key2)) {//键相等                Object value1 = this.getValue();                Object value2 = entry.getValue();                if (value1 == value2 || value1 != null && value1.equals(value2))//值相等                    return true;            }            return false;        }        //重写hashCode()        @Override        public int hashCode() {            return ((key == null) ? 0 : key.hashCode()) ^ ((value == null) ? 0 : value.hashCode());        }        //        @Override        public String toString() {            return getKey() + "=" + getValue();        }        // 使用该方法证明该key已经在该map中        void recordAccess(HashMap<K, V> map) {        }        // 该方法记录该key已经被移除了        void recordRemoval(HashMap<K, V> map) {        }    }    /*----------------------HashMap内方法-----------------------------------*/    /**     * 方法: 添加新的节点     */    private void addEntry(int hash, K key, V value, int bucketIndex) {        // 保存对应table的值        Entry<K, V> e = table[bucketIndex];        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);        // 如果当前size大于等于阈值        if (size++ >= threshold)            // 调整容量 HashMap采用两倍扩容            resize(2 * table.length);    }    /**     * 方法: 创建新的节点     */    void createEntry(int hash, K key, V value, int bucketIndex) {        Entry<K, V> e = table[bucketIndex];        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);        size++;    }    @Override    public Set<Map.Entry<K, V>> entrySet() {        return null;    }}