（源码分析）JDK1.7 HashMap源码分析

喜欢ヅ旅行 2021-10-19 06:28 538阅读 0赞

### 目录 ###

*   *  成员变量：
     *  构造方法
     *  Entry<K,V>
     *  put(K key, V value)
     *  get(K key)
     *  remove(Object key)
     *  containsKey(Object key)
     *  containsValue(Object value)
     *  keySet()
     *  values()
     *  entrySet()
     *  clear()
     *  size()
     *  isEmpty()
 *  总结

**说明： 当前HashMap的版本为JDK1.7.0.80**

## 成员变量： ##

transient int modCount; // 修改次数，当进行put、remove等操作时将会加1
    static final Entry<?,?>[] EMPTY_TABLE = { }; // 空数组
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认大小为16
    static final float DEFAULT_LOAD_FACTOR = 0.75f; // 加载因子，当HashMap中的元素到达当前大小*0.75时，HashMap将会扩容为原来的2倍
    int threshold; // 阈值，为当前HashMap容量*加载因子的值
    transient int hashSeed = 0; // 哈希码
    static final int MAXIMUM_CAPACITY = 1 << 30; // HashMap设置的最大容量
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE; // Entry数组，虽然JDK1.7的HashMap是数组+链表组成的，但是HashMap中的元素都可以看做是一个Entry数组
    transient volatile Set<K> keySet = null; // HashMap中key的set集合
    transient volatile Collection<V> values = null; // HashMap中value值的Collection集合
    private transient Set<Map.Entry<K,V>> entrySet = null; // HashMap中Entry元素set集合

## 构造方法 ##

*  HashMap()：无参构造方法

/** * 使用HashMap默认的初始化大小16和默认的加载因子0.75 */
    public HashMap() { 
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

*  HashMap(int initialCapacity)：指定初始化容量

/** * 指定HashMap初始化大小，使用默认的加载因子0.75 */
    public HashMap(int initialCapacity) { 
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

*  HashMap(int initialCapacity)：指定初始化容量和加载因子

/** * 指定HashMap初始化大小和加载因子 */
    public HashMap(int initialCapacity, float loadFactor) { 
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init();
    }
    
    /** * 在JDK1.7.0.80中init()方法并未提供实现 */
    void init() { 
    }

## Entry<K,V> ##

**内部类Entry说明：**

> 1、Entry主要包含三个成员变量，key：HashMap的key；value：HashMap的value；next：指向下一个Entry  
> 2、HashMap其实可以看做是一个Entry的集合，每一个key和value都封装在Entry元素中

**HashMap原理图：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NjIwNTAx_size_16_color_FFFFFF_t_70]

**内部类Entry源码：**

static class Entry<K,V> implements Map.Entry<K,V> { 
        final K key;
        V value;
        Entry<K,V> next;
        int hash;
    
        Entry(int h, K k, V v, Entry<K,V> n) { 
            value = v;
            next = n;
            key = k;
            hash = h;
        }
    
        public final K getKey() { 
            return key;
        }
    
        public final V getValue() { 
            return value;
        }
    
        public final V setValue(V newValue) { 
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
    
        public final boolean equals(Object o) { 
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) { 
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }
    
        public final int hashCode() { 
            return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
        }
    
        public final String toString() { 
            return getKey() + "=" + getValue();
        }
    
        void recordAccess(HashMap<K,V> m) { 
        }
    
        void recordRemoval(HashMap<K,V> m) { 
        }
    }

## put(K key, V value) ##

**put(K key, V value)执行原理：**

> 1、首先对此HashMap进行判断是否为空，如果为null，初始化此HashMap，初始化threshold(阙值)，table(Entry数组)，hashSeed(哈希吗)  
> 2、判断key是否为null，如果为null，先判断此HashMap中是否有key为null的元素，如果存在，则替换并返回替换的value值；如果不存在，则在table数组下标为0的位置上添加key为null的Entry元素  
> 3、通过哈希算法获得key的哈希值，同时获取此hash值在table数组的下标i  
> 4、遍历下标为i处的链表，如果链表中存在相同的key，替换并返回替换的value值；如果不存在，则在此table下标为i的位置上添加一个Entry元素

**put(K key, V value)源码：**

/** * 添加元素 */
    public V put(K key, V value) { 
        if (table == EMPTY_TABLE) {  // 当HashMap为空时
            inflateTable(threshold); // 初始化此HashMap，在new HashMap*()时，如果未指定初始化容量，默认容量为16
        }
        if (key == null) // 当key为null时
            return putForNullKey(value); // 替换HashMap中原有的key为null的value值，然后此put方法结束
        int hash = hash(key); // 计算key的哈希值
        int i = indexFor(hash, table.length); // 获取HashMap数组下标
        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))) {  // 当key与Entry中存在key相等并且hash值也一样时，替换原来的值，并将原来的值返回出去
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(hash, key, value, i); // 如果哦在此HashMap中并未存在此key，则添加Entry元素
        return null;
    }
    
    /** * 初始化HashMap，在new HashMap()时，如果未指定初始化容量，默认容量为16 */
    private void inflateTable(int toSize) { 
        int capacity = roundUpToPowerOf2(toSize); // 找到比toSize大2的次方的数的最小值
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); // 获取阙值=新的容量*加载因子与HashMap最大容量+1之间的大小，确保新的阙值不会超过HashMap所能容纳的最大大小
        table = new Entry[capacity]; // 初始化Entry数组
        initHashSeedAsNeeded(capacity);
    }
    
    /** * 找到比toSize大2的次方的数的最小值，因为HashMap的大小都因为2的次方 */
    private static int roundUpToPowerOf2(int number) { 
        return number >= MAXIMUM_CAPACITY
            ? MAXIMUM_CAPACITY
            : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }
    
    /** * hashseed默认值为0，如果key的类型是String时采用sun.misc.Hashing.stringHash32的方式获取哈希值，在JDK1.8 中，hashSeed已经被移除掉了，移除掉的原因是调用sun.misc.Hashing.randomHashSeed计算hashSeed时会调用方法java.util.Random.nextInt()，该方法使用AtomicLong，在多线程情况下会有性能问题 */
    final boolean initHashSeedAsNeeded(int capacity) { 
        boolean currentAltHashing = hashSeed != 0;
        boolean useAltHashing = sun.misc.VM.isBooted() &&
            (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean switching = currentAltHashing ^ useAltHashing;
        if (switching) { 
            hashSeed = useAltHashing
                ? sun.misc.Hashing.randomHashSeed(this)
                : 0;
        }
        return switching;
    }
    
    /** * 替换HashMap中原有的key为null的value值 */
    private V putForNullKey(V value) { 
        for (Entry<K,V> e = table[0]; e != null; e = e.next) { 
            if (e.key == null) { 
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0); // 如果在HashMap中没有key为null的元素，将key为null的Entry放置在HashMap哈希值为0的位置并且数组索引也为0的位置，也就是说key为null的值都存放在HashMap首位
        return null;
    }
    
    /** * 如果在HashMap中没有key为null的元素，将key为null的Entry放置在HashMap哈希值为0的位置并且数组索引也为0的位置 */
    void addEntry(int hash, K key, V value, int bucketIndex) { 
        if ((size >= threshold) && (null != table[bucketIndex])) {  // 当HashMap的元素个数大于或等于阈值并且HashMap在此下标处存在元素时
            resize(2 * table.length); // 对HashMap的大小进行扩容，为原来的2倍，所以HashMap的大小都是2的次方
            hash = (null != key) ? hash(key) : 0; // 计算key的哈希值
            bucketIndex = indexFor(hash, table.length); // 根据新的哈希值和HashMap的长度计算新的下标
        }
        createEntry(hash, key, value, bucketIndex);
    }
    
    /** * 对HashMap的大小进行扩容，为原来的2倍 */
    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)); // 将当前Entry数组中的元素转义到新的Entry数组中
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }
    
    /** * 将当前Entry数组中的元素转义到新的Entry数组中 */
    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;
            }
        }
    }
    
    /** * 创建Entry元素，添加到Entry数组中 */
    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++;
    }
        
    /** * 计算key的哈希值 */
    final int hash(Object k) { 
        int h = hashSeed;
        if (0 != h && k instanceof String) { 
            return sun.misc.Hashing.stringHash32((String) k); // 当hashSeed不等于0时并且key为String类型时，采用sun.misc.Hashing.stringHash32计算key的哈希值
        }
        h ^= k.hashCode();
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

## get(K key) ##

**get(K key)执行原理：**

> 1、首先先判断key是否为null，如果为null，在table\[0\]出的链表寻找key为null的Entry元素的value值，如果不存在key为null的Entry，则返回null  
> 2、当key不为null时，计算key的哈希值，根据hash值获取该key在此HashMap在table的下标，然后遍历该下标处的链表，如果链表中存在key相同的Entry元素，则返回此Entry元素的value值，如果不存在则返回null

**get(K key)源码：**

/** * 获取元素 */
    public V get(Object key) { 
        if (key == null)
            return getForNullKey(); // 获取key为null的Entry元素的value值
        Entry<K,V> entry = getEntry(key); // 根据指定key获取Entry元素
        return null == entry ? null : entry.getValue(); // 如果Entry存在则获取它的value值
    }
    
    /** * 获取key为null的Entry元素的value值 */
    private V getForNullKey() { 
        if (size == 0) { 
            return null;
        }
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {  // 遍历table下标为0的链表，因为key为null的Entry元素在下标为0的位置
            if (e.key == null)
                return e.value;
        }
        return null;
    }
    
    /** * 根据指定key获取Entry元素 */
    final Entry<K,V> getEntry(Object key) { 
        if (size == 0) { 
            return null;
        }
        int hash = (key == null) ? 0 : hash(key); // 获取key的哈希值
        for (Entry<K,V> e = table[indexFor(hash, table.length)]; // 根据hash值获取该key在此HashMap在table的下标，然后遍历该下标处的链表
             e != null;
             e = e.next) { 
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

## remove(Object key) ##

**remove(Object key)执行原理：**

> 1、获取key的hash值  
> 2、根据hash值获取该key在此HashMap在table的下标i  
> 3、循环遍历table数组下标为i处的链表，如果存在该key，删除此Entry元素并将删除的Entry元素中的value值返回  
> 4、如果table数组下标为i处没有元素或者此处链表中的元素并未找到此key，则返回null

**remove(Object key)源码：**

/** * 删除指定key的Entry元素 */
    public V remove(Object key) { 
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }
    
    /** * 删除指定key的Entry元素 */
    final Entry<K,V> removeEntryForKey(Object key) { 
        if (size == 0) { 
            return null;
        }
        int hash = (key == null) ? 0 : hash(key); // 获取key的hash值
        int i = indexFor(hash, table.length); // 根据hash值获取该key在此HashMap在table的下标
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;
    
        while (e != null) {  // 循环遍历table数组下标为i处的链表
            Entry<K,V> next = e.next;
            Object k;
            if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {  // 如果存在该key，删除此Entry元素并将删除的Entry元素返回
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }
    
        return e; // 当table数组下标为i处没有元素或者此处链表中的元素并未找到此key，则返回null
    }
    
    /** * 计算key的hash值 */
    final int hash(Object k) { 
        int h = hashSeed;
        if (0 != h && k instanceof String) { 
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h ^= k.hashCode();
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
    
    /** * 根据hash值获取该key在此HashMap在table的下标 */
    static int indexFor(int h, int length) { 
        return h & (length-1);
    }

## containsKey(Object key) ##

**containsKey(Object value)执行原理：**

> 1、获取key的哈希值  
> 2、根据hash值获取该key在此HashMap在table的下标  
> 3、然后遍历该下标处的链表，如果存在此Entry元素，则返回true，不存在则返回null

**containsKey(Object value)源码：**

/** * 判断此HashMap中是否存在此key */
    public boolean containsKey(Object key) { 
        return getEntry(key) != null; // 根据指定key获取Entry元素，如果存在返回true，不存在则返回false
    }
    
    /** * 根据指定key获取Entry元素 */
    final Entry<K,V> getEntry(Object key) { 
        if (size == 0) { 
            return null;
        }
    
        int hash = (key == null) ? 0 : hash(key); // 获取key的哈希值
        for (Entry<K,V> e = table[indexFor(hash, table.length)]; // 根据hash值获取该key在此HashMap在table的下标，然后遍历该下标处的链表
             e != null;
             e = e.next) { 
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

## containsValue(Object value) ##

**containsValue(Object value)执行原理：**

> 1、判断value值是否为null，如果为null，循环遍历table数组和和其下标处的链表判断此HashMap中是否存在value值为null的Entry元素  
> 2、如果value值不为null，循环遍历table数组和和其下标处的链表判断此HashMap中是否存在指定value值的Entry元素

**containsValue(Object value)源码：**

/** * 判断此HashMap中是否存在此value值 */
    public boolean containsValue(Object value) { 
        if (value == null) // 如果value值为null
            return containsNullValue(); // 判断此HashMap中是否value值为null的Entry元素
    
        Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++) // 循环遍历table数组和和其下标处的链表判断此HashMap中是否存在指定value值的Entry元素
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (value.equals(e.value))
                    return true;
        return false;
    }
    
    /** * 判断此HashMap中是否value值为null的Entry元素 */
    private boolean containsNullValue() { 
        Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++) // 循环遍历table数组和和其下标处的链表判断此HashMap中是否存在value值为null的Entry元素
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (e.value == null)
                    return true;
        return false;
    }

## keySet() ##

**keySet()执行原理：**

> 1、判断keySet是否为null，如果为null则new KeySet()  
> 2、但是在内部类KeySet中和其父类的构造方法中并没有将HashMap中的key保存在keySet中，所以在new KeySet()时该set集合是空的，它是通过迭代器遍历时去遍历HashMap中的Entry元素中的key值

**keySet()源码：**

/** * 获取Entry元素中key值的set集合 */
    public Set<K> keySet() { 
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }
    
    /** * HashMap内部类KeySet继承自抽象类AbstractSet */
    private final class KeySet extends AbstractSet<K> { 
        public Iterator<K> iterator() { 
            return newKeyIterator();
        }
        public int size() { 
            return size;
        }
        public boolean contains(Object o) { 
            return containsKey(o);
        }
        public boolean remove(Object o) { 
            return HashMap.this.removeEntryForKey(o) != null;
        }
        public void clear() { 
            HashMap.this.clear();
        }
    }
    
    /** * 返回内部类KeyIterator的实例 */
    Iterator<K> newKeyIterator()   { 
        return new KeyIterator();
    }
    
    /** * 内部类KeyIterator，继承自HashIterator抽象类 */
    private final class KeyIterator extends HashIterator<K> { 
        public K next() { 
            return nextEntry().getKey();
        }
    }
    
    /** * 内部抽象类HashIterator */
    private abstract class HashIterator<E> implements Iterator<E> { 
        Entry<K,V> next;
        int expectedModCount; // For fast-fail
        int index;
        Entry<K,V> current;
    
        HashIterator() { 
            expectedModCount = modCount;
            if (size > 0) { 
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }
    
        public final boolean hasNext() { 
            return next != null;
        }
    
        final Entry<K,V> nextEntry() { 
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();
    
            if ((next = e.next) == null) { 
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }
    
        public void remove() { 
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }

## values() ##

**values()执行原理：**

> 1、判断keySet是否为null，如果为null则new KeySet()  
> 2、但是在内部类KeySet中和其父类的构造方法中并没有将HashMap中的key保存在keySet中，所以在new KeySet()时该set集合是空的，它是通过迭代器遍历时去遍历HashMap中的Entry元素中的key值

**values()源码：**

/** * 获取Entry元素中value值的Collection集合 */
    public Collection<V> values() { 
        Collection<V> vs = values;
        return (vs != null ? vs : (values = new Values()));
    }
    
    /** * HashMap内部类Values继承自抽象类AbstractCollection */
    private final class Values extends AbstractCollection<V> { 
        public Iterator<V> iterator() { 
            return newValueIterator();
        }
        public int size() { 
            return size;
        }
        public boolean contains(Object o) { 
            return containsValue(o);
        }
        public void clear() { 
            HashMap.this.clear();
        }
    }
    
    /** * 返回内部类ValueIterator的实例 */
    Iterator<V> newValueIterator()   { 
        return new ValueIterator();
    }
    
    /** * 内部类ValueIterator，继承自HashIterator抽象类 */
    private final class ValueIterator extends HashIterator<V> { 
        public V next() { 
            return nextEntry().value;
        }
    }
    
    /** * 内部抽象类HashIterator */
    private abstract class HashIterator<E> implements Iterator<E> { 
        Entry<K,V> next;
        int expectedModCount; // For fast-fail
        int index;
        Entry<K,V> current;
    
        HashIterator() { 
            expectedModCount = modCount;
            if (size > 0) { 
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }
    
        public final boolean hasNext() { 
            return next != null;
        }
    
        final Entry<K,V> nextEntry() { 
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();
    
            if ((next = e.next) == null) { 
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }
    
        public void remove() { 
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }

## entrySet() ##

**entrySet()执行原理：**

> 1、entrySet()的执行原理和keySet()基本一致  
> 2、判断entrySet是否为null，如果为null则new EntrySet()  
> 3、但是在内部类EntrySet中和其父类的构造方法中并没有将HashMap中的Entry元素保存在entrySet中，所以在new EntrySet()时该set集合是空的，它是通过迭代器遍历时去遍历HashMap中的Entry元素

**entrySet()源码：**

/** * 获取Entry元素set集合 */
    public Set<Map.Entry<K,V>> entrySet() { 
        return entrySet0();
    }
    
    /** * 判断entrySet是否为null，如果为null则new EntrySet() */
    private Set<Map.Entry<K,V>> entrySet0() { 
        Set<Map.Entry<K,V>> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }
    
    /** * 静态内部类EntrySet，继承自抽象类AbstractSet */
    private final class EntrySet extends AbstractSet<Map.Entry<K,V>> { 
        public Iterator<Map.Entry<K,V>> iterator() { 
            return newEntryIterator();
        }
        public boolean contains(Object o) { 
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<K,V> e = (Map.Entry<K,V>) o;
            Entry<K,V> candidate = getEntry(e.getKey());
            return candidate != null && candidate.equals(e);
        }
        public boolean remove(Object o) { 
            return removeMapping(o) != null;
        }
        public int size() { 
            return size;
        }
        public void clear() { 
            HashMap.this.clear();
        }
    }
    
    /** * 返回迭代器静态内部类EntryIterator */
    Iterator<Map.Entry<K,V>> newEntryIterator()   { 
        return new EntryIterator();
    }
    
    /** * 静态内部类EntryIterator，继承自抽象内部类HashIterator */
    private final class EntryIterator extends HashIterator<Map.Entry<K,V>> { 
        public Map.Entry<K,V> next() { 
            return nextEntry();
        }
    }
    
    /** * 内部抽象类HashIterator */
    private abstract class HashIterator<E> implements Iterator<E> { 
        Entry<K,V> next;
        int expectedModCount; // For fast-fail
        int index;
        Entry<K,V> current;
    
        HashIterator() { 
            expectedModCount = modCount;
            if (size > 0) { 
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }
    
        public final boolean hasNext() { 
            return next != null;
        }
    
        final Entry<K,V> nextEntry() { 
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();
    
            if ((next = e.next) == null) { 
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }
    
        public void remove() { 
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }

## clear() ##

**clear()执行原理：**

> 通过调用Arrays.fill()方法循环table数组，将数组中的元素设置为null

**clear()源码：**

/** * 将HashMap中的元素清空 */
    public void clear() { 
        modCount++;
        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;
    }

## size() ##

**size()执行原理：**

> 直接返回此HashMap中的元素个数

**size()源码：**

/** * 返回此HashMap中的元素个数 */
     public int size() { 
    	return size;
     }

## isEmpty() ##

**isEmpty()执行原理：**

> 判断此HashMap中的元素个数是否为0

**isEmpty()源码：**

/** * 判断此HashMap中的元素个数是否为0 */
    public boolean isEmpty() { 
        return size == 0;
    }

# 总结 #

*  JDK1.7的HashMap底层是使用数据+链表
 *  HashMap是线程不安全的，内部使用fast-fail机制当在使用HashMap中出现了线程安全问题时，将会抛出ConcurrentModificationException来提交你，避免你继续错下去
 *  HashMap中的元素都可以看做是一个Entry元素，Entry主要包含三个成员变量，key：HashMap的key；value：HashMap的value；next：指向下一个Entry，每一个key和value都封装在Entry元素中
 *  keySet()、values()、entrySet()方法返回的都是空的内部实现类，该内部类在返回的时候内部并没有元素，同时HashMap在put()的时候也并未特意将元素添加到内部类中，它是在迭代器遍历的时候遍历table数据中的Entry元素，也可以使用foreach遍历(底层也是使用迭代器遍历)，set集合和collection集合中并未提供get()方法，所以不能使用普通for循环来遍历

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NjIwNTAx_size_16_color_FFFFFF_t_70]: /images/20211018/8753f1544a50492881e732f08501515e.png

发表评论取消回复

表情：

评论列表（有 0 条评论，538人围观）

还没有评论，来说两句吧...

相关阅读

相关（源码分析）JDK1.8 HashMap源码分析

目录 * * 成员变量 * 构造方法 * Node<K,V> * TreeNode<K,V> * put(K ...

Myth丶恋晨/ 2024年04月17日 06:24/ 0 赞/ 83 阅读

相关 HashMap JDK7源码分析

概述 HashMap是基于哈希表(散列表)，实现Map接口的双列集合，数据结构是“链表散列”，也就是数组+链表，key唯一的value可以重复，允许存储null 键nu

ゝ一纸荒年。/ 2022年12月30日 08:26/ 0 赞/ 286 阅读

相关 HashMap JDK8 源码分析

概述 HashMap是基于哈希表(散列表)，实现Map接口的双列集合，数据结构是“链表散列”，也就是数组+链表，key唯一的value可以重复，允许存储null 键nu

朱雀/ 2022年12月30日 08:13/ 0 赞/ 297 阅读

相关【Java源码分析】HashMap源码分析

类的定义 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>

谁践踏了优雅/ 2022年09月23日 09:00/ 0 赞/ 366 阅读

相关 HashMap源码分析

[https://mp.weixin.qq.com/s/lgYpJhKHoKh3avjPux6Rvg][https_mp.weixin.qq.com_s_lgYpJhKHoKh

小灰灰/ 2022年05月26日 07:15/ 0 赞/ 378 阅读

相关 HashMap源码分析

作为Collection集合类中的一个重要成员，HashMap无论在应用、笔试还是面试中都占了很大的比例，纵观网上的源码分析，很多都基于了JDK 1.8以前的版本进行了分析，但

布满荆棘的人生/ 2022年05月23日 02:28/ 0 赞/ 351 阅读

相关 hashmap源码分析

文章目录 hashmap源码分析简介 hashmap数据结构 hashmap的数据结构实现桶，链表的

我不是女神ヾ/ 2022年05月22日 07:56/ 0 赞/ 321 阅读

相关 JDK11源码--HashMap源码分析

文章目录欢迎关注本人公众号概述 hashmap数据结构基本参数 \`MAXIMUM\_CAPACITY\`为什么设置成1 <<

ゝ一纸荒年。/ 2022年03月16日 04:50/ 0 赞/ 398 阅读

相关 JDK源码分析－－Properties源码分析

注：以下分析基于JDK1.8.0\_74。一、概述 1、Properties类表示一组持久属性。属性列表中的每个键及其对

深碍√TFBOYSˉ_/ 2022年02月27日 03:38/ 0 赞/ 520 阅读

相关（源码分析）JDK1.7 HashMap源码分析

目录成员变量：构造方法 Entry<K,V> put(K key, V value) get(K

喜欢ヅ旅行/ 2021年10月19日 06:28/ 0 赞/ 539 阅读