Java HashMap源代码详解

Java HashMap源代码详解

HashMap链地址法确定存储位置

　　将所有关键字为同义词的记录存储在同一线性表中。假设某哈希函数产生的哈希地址在区间[0,m-1]上，则设立一个指针型向量Chain Chain Hash[m];

其每个分量的初始状态都是空指针。凡是哈希地址为i的记录都插入到头指针为ChainHash[i]的链表中。在列表中的插入位置可以在表头或表尾；也可以在中间，以保持同义词在同一线性表中按关键字有序。

　　例如：已知一组关键字为（19，14，23，01，68，20，84，27，55，11，10，79），则按哈希函数H(key)=key MOD 13 和链地址法处理冲突构造所得的哈希表，如下图所示：

                           

Hash map=New HashMap();

HashMap基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。

说明：

　　数据存放在数组中，但物理存储是链式存储

　　数组成员成为格子，且每个格子的hash值的唯一的

　　每个格子可存放hash值相同的多对K-V，每对被称为桶（每个桶是唯一的即Map存放数据不可重复）

　　格子中的桶与桶之间是通过指针连接的（Map是无序的）

处理流程：

　　1、创建默认初始容量16，加载因子 (0.75)

　　2、通过public V put(K key, V value);先计算key的hash值，确定key所在的格子（如果为空则需要创建一个新桶存放K-V，不为空则覆盖旧桶）

　　3、每次创建一个桶则size大小进行记录，并在创建新桶后进行判断size与threshold阈值变量比较，如果size>threshold则需要扩充格子容量原来的2倍。

HashMap源码

package java2.util2;

import java.io.IOException;
import java.io.Serializable;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Set;
/**
 * HashMap
 * @author wwl
 *
 * @param <K>
 * @param <V>
 */
public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>,
        Cloneable, Serializable {

    // 系统默认初始容量，必须是2的n次幂，这是出于优化考虑的
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    // 系统默认最大容量2的30次幂1073741824
    static final int MAXIMUM_CAPACITY = 1 << 30;

    // 系统默认负载因子，可在构造函数中指定
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    // 用于存储的表，长度可以调整，且必须是2的n次幂
    transient Entry[] table;

    // 当前map的key-value映射数，也就是当前size  
    transient int size;

    /**
     * 表示HashMap所能容纳的key-value对极限，如果存储的size数大于了threshold，则需要扩容了
     * 阈值 
     * @serial
     */
    int threshold;

    /**
     * 哈希表的负载因子  
     * loadFactor是负载因子，增大值时可以减少Hash表（也就是Entry数组）所占用的内存空间，
     * 但会增加查询数据时时间的开销，而查询是最频繁的操作，减小值时会提高数据查询的性能， 但是会增大Hash表所占用的内存空间，所以一般是默认的0.75
     * 
     * @serial
     */
    final float loadFactor;

    /**
     * 用于确保使用迭代器的时候，HashMap并未进行更改 
     */
    transient volatile int modCount;

    /**
     * 构造一个带指定初始容量和加载因子的空 HashMap
     * 
     * @param initialCapacity
     *            初始容量
     * @param loadFactor
     *            加载因子
     * @throws IllegalArgumentException
     *             if the initial capacity is negative or the load factor is
     *             nonpositive
     */
    public HashMap(int initialCapacity, float loadFactor) {
        // 如果指定初始容量小于0，抛错 
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: "
                    + initialCapacity);
        // 如果初始容量大于系统默认最大容量，则初始容量为最大容量 
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        // 如果loadFactor小于0，或loadFactor是NaN，则抛错  
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: "
                    + loadFactor);
        // 寻找一个2的k次幂capacity恰好大于initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            // 计算出大于initialCapacity的最小的2的n次方值
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int) (capacity * loadFactor);// 设置容量极限
        // 创建一个capacity长度的数组用于保存数据
        table = new Entry[capacity];
        init();
    }

    /**
     * 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
     * 
     * @param initialCapacity
     *            初始容量
     * @throws IllegalArgumentException
     *             if the initial capacity is negative.
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

    /**
     * 构造一个映射关系与指定 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);
        putAllForCreate(m);
    }
    /**
     * 初始化
     */
    void init() {
    }

    /**
     * HashMap的哈希函数
     * 预处理hash值，避免较差的离散hash序列
     * @param h
     * @return
     */
    static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    /**
     *  返回对应hash值得索引
     *  根据key的hash值获取哈希地址
     * @param h
     * @param length
     * @return
     */
    static int indexFor(int h, int length) {
        //由于length是2的n次幂，所以h & (length-1)相当于h % length
        return h & (length - 1);
    }

    /**
     * 返回当前map的key-value映射数，也就是当前size
     */
    public int size() {
        return size;
    }
    /**
     * 该HashMap是否是空的，如果size为0，则为空
     */
    public boolean isEmpty() {
        return size == 0;
    }
    /**
     * 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null
     * 先根据输入的key计算hash值，得出index，找到对应数组节点，在节点内的链表结构中遍历寻找所求数据
     */
    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        // 得到对应的hash值的桶，如果这个桶不是，就通过next获取下一个桶
        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.equals(k)))
                return e.value;
        }
        return null;
    }
    /**
     * 如果要得到key为null的值，则通过这个获取
     * @return
     */
    private V getForNullKey() {
        for (Entry<K, V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

    /**
     * 如果此映射包含对于指定键的映射关系，则返回 true
     */
    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    /**
     * 通过key获取一个value 
     */
    final Entry<K, V> getEntry(Object key) {
        // 如果key为null，则hash为0，否则用hash函数预处理
        int hash = (key == null) ? 0 : hash(key.hashCode());
        // 先得到对应的hash值的桶，再比较key值如果这个桶不是，就通过next获取下一个桶
        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;
    }

    /**
     * 存放K-V
     * 采用链地址法
     * 哈希值[0,m-1],先计算hash根据哈希存放到对应hash值桶中，可以存放多个相同的hash
     * 在此映射中关联指定值与指定键。如果该映射以前包含了一个该键的映射关系，则旧值被替换
     */
    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        // 先得到对应的hash值的格子，判断该hash值的格子中下是否已经存储数据，若不为空则已存在，则新数据需要通过next获取下一个桶
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 如果hash相同并且key相同 ，则旧值被替换
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

    /**
     * 当key为空时进行存放
     * 物理存储采用链表结构
     */
    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);
        return null;
    }

    /**
     * 检查当前已创建的桶是存在
     */
    private void putForCreate(K key, V value) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);

        // 遍历所有桶  
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            Object k;
             // 如果有hash相同，且key相同，那么则不需要创建新的桶，退出
            if (e.hash == hash
                    && ((k = e.key) == key || (key != null && key.equals(k)))) {
                e.value = value;
                return;
            }
        }
        //否则,不存在hash值桶需要创建新的桶
        createEntry(hash, key, value, i);
    }
    /**
     * 根据Map创建所有对应的桶  
     * @param m
     */
    private void putAllForCreate(Map<? extends K, ? extends V> m) {
        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m
                .entrySet().iterator(); i.hasNext();) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            putForCreate(e.getKey(), e.getValue());
        }
    }

    /**
     * 根据新的容量来resize这个HashMap
     * @param newCapacity
     */
    void resize(int newCapacity) {
        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中 
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K, V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K, V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

    /**
     * 将另一个Map对象copy到当前对象
     * 将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系  
     */
    public void putAll(Map<? extends K, ? extends V> m) {
        // 需要复制多少个映射关系 
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;

        // 如果要复制的映射关系比阈值还要多
        if (numKeysToBeAdded > threshold) {
            // 重新计算新的容量先resize 
            int targetCapacity = (int) (numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            if (newCapacity > table.length)
                resize(newCapacity);
        }
        // 迭代将key-value映射放进该HashMap
        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m
                .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> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    /**
     * 根据key删除桶，并返回对应value
     */
    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> e = prev;
        // 遍历所有桶 
        while (e != null) {
            Entry<K, V> next = e.next;
            Object k;
            // 如果找到对应的桶 
            if (e.hash == hash
                    && ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                // 如果第一个就是要删的桶
                if (prev == e)
                    // 则table[i]等于下一个桶
                    table[i] = next;
                else
                    // 否则上一个桶的下一个等于下一个桶
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    /**
     * 根据桶来删除map里的值
     */
    final Entry<K, V> removeMapping(Object o) {
        // 如果o不是Map.Entry的实例，则退出返回null
        if (!(o instanceof Map.Entry))
            return null;
        // 将o转成Map.Entry 
        Map.Entry<K, V> entry = (Map.Entry<K, V>) o;
        Object key = entry.getKey();
        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;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    /**
     * 从此映射中移除所有映射关系。此调用返回后，映射将为空
     */
    public void clear() {
        modCount++;
        Entry[] tab = table;
        // 遍历table中的所有格子，然偶后设为nul
        for (int i = 0; i < tab.length; i++)
            tab[i] = null;
        size = 0;
    }

    /**
     * 如果此映射将一个或多个键映射到指定值，则返回 true 
     */
    public boolean containsValue(Object value) {
        // 如果value为空，则返回containsNullValue函数的返回值
        if (value == null)
            return containsNullValue();

        Entry[] tab = table;
        // 遍历table所有格子（链表）
        for (int i = 0; i < tab.length; i++)
            // 遍历链表中的每个桶
            for (Entry e = tab[i]; e != null; e = e.next)
                // 如果值相同，则返回true 
                if (value.equals(e.value))
                    return true;
        return false;
    }

    /**
     * 对value为null的处理
     */
    private boolean containsNullValue() {
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            for (Entry e = tab[i]; e != null; e = e.next)
                if (e.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) {
            // assert false;
        }
        result.table = new Entry[table.length];
        result.entrySet = null;
        result.modCount = 0;
        result.size = 0;
        result.init();
        result.putAllForCreate(this);

        return result;
    }
    /**
     * 内置class输入对象，也就是桶
     * @author wwl
     *
     * @param <K>
     * @param <V>
     */
    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 final V getValue() {
            return value;
        }
        /**
         * 设置value
         */
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        /**
         * 是否相同,比对的是key与value
         */
        public final boolean equals(Object o) {
             // 如果o不是Map.Entry的实例，那么肯定不相同了
            if (!(o instanceof Map.Entry))
                return false;
            // 将o转成Map.Entry
            Map.Entry e = (Map.Entry) o;
            // 得到key和value对比是否相同，相同则为true
            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 (key == null ? 0 : key.hashCode())
                    ^ (value == null ? 0 : value.hashCode());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /**
         * 使用该方法证明该key已经在该map中
         */
        void recordAccess(HashMap<K, V> m) {
        }

        /**
         * 该方法记录该key已经被移除了
         */
        void recordRemoval(HashMap<K, V> m) {
        }
    }

    /**
     * 添加一个新的桶来保存该key和value
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K, V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);
        if (size++ >= threshold)
            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++;
    }
    /**
     * 内部class HashIterator迭代器
     * @author wwl
     *
     * @param <E>
     */
    private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K, V> next; // 下一个桶
        int expectedModCount; // 保护HashMap没有变更
        int index; // 当前的索引
        Entry<K, V> current; // 当前的桶

        HashIterator() {
             // 保存modCount，因为如果HashMap进行了任何操作modCount都会增加，所以如果发现modCount变化了，就可以抛出失败
            expectedModCount = modCount;
            if (size > 0) { // 进入第一个桶 
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }
        /**
         * 判断有没有下一个桶 
         */
        @Override
        public final boolean hasNext() {
            return next != null;
        }
        /**
         * 获取下一个桶 
         * @return
         */
        final Entry<K, V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K, V> e = next;
            // 如果next为空，抛出失败
            if (e == null)
                throw new NoSuchElementException();
            // 如果next.next为空，将next定义为下一个格子中的桶，否则为该格子的下一个桶
            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }
        /**
         * 删除
         */
        @Override
        public void remove() {
            // 如果当前为空，抛出
            if (current == null)
                throw new IllegalStateException();
            // modCount变化了，抛出失败
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            // 获得当前的key
            Object k = current.key;
             // 设置current为null 
            current = null;
            // 删除掉对应key的元素
            HashMap.this.removeEntryForKey(k);
            // 重置expectedModCount
            expectedModCount = modCount;
        }

    }
    /**
     * 内部class ValueIterator迭代器，重写next方法
     * @author wwl
     *
     */
    private final class ValueIterator extends HashIterator<V> {
        @Override
        public V next() {
            return nextEntry().value;
        }
    }
    /**
     * 内部class KeyIterator迭代器，重写next方法
     * @author wwl
     *
     */
    private final class KeyIterator extends HashIterator<K> {
        public K next() {
            return nextEntry().getKey();
        }
    }
    /**
     * 内部class EntryIterator迭代器，重写next方法
     * @author wwl
     *
     */
    private final class EntryIterator extends HashIterator<Map.Entry<K, V>> {
        public Map.Entry<K, V> next() {
            return nextEntry();
        }
    }

    /**
     * 定义对应的 iterator() 方法
     * @return
     */
    Iterator<K> newKeyIterator() {
        return new KeyIterator();
    }
    /**
     * 定义对应的 iterator() 方法
     * @return
     */
    Iterator<V> newValueIterator() {
        return new ValueIterator();
    }
    /**
     * 定义对应的 iterator() 方法
     * @return
     */
    Iterator<Map.Entry<K, V>> newEntryIterator() {
        return new EntryIterator();
    }

    // Views

    private transient Set<Map.Entry<K, V>> entrySet = null;

    /**
     * 返回此映射中所包含的键的 Set 视图
     */
    public Set<K> keySet() {
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }

    /**
     * 内部类KeySet对象
     * @author wwl
     * 
     */
    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();
        }
    }

    /**
     * 返回此映射所包含的值的 Collection 视图
     */
    public Collection<V> values() {
        Collection<V> vs = values;
        return (vs != null ? vs : (values = new Values()));
    }

    /**
     * 内部类Values 
     * 
     * @author wwl
     * 
     */
    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();
        }
    }

    /**
     * 返回此映射所包含的映射关系的 Set 视图
     */
    public Set<Map.Entry<K, V>> entrySet() {
        return entrySet0();
    }

    private Set<Map.Entry<K, V>> entrySet0() {
        Set<Map.Entry<K, V>> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }

    /**
     *  内部类EntrySet对象
     * 
     * @author wwl
     * 
     */
    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();
        }
    }

    /**
     * 序列化方法
     */
    private void writeObject(java.io.ObjectOutputStream s) throws IOException {
        Iterator<Map.Entry<K, V>> i = (size > 0) ? entrySet0().iterator()
                : null;

        s.defaultWriteObject();

        s.writeInt(table.length);

        s.writeInt(size);

        if (i != null) {
            while (i.hasNext()) {
                Map.Entry<K, V> e = i.next();
                s.writeObject(e.getKey());
                s.writeObject(e.getValue());
            }
        }
    }

    private static final long serialVersionUID = 362498820763181265L;

    /**
     * 通过序列读取对象
     */
    private void readObject(java.io.ObjectInputStream s) throws IOException,
            ClassNotFoundException {
        s.defaultReadObject();

        int numBuckets = s.readInt();
        table = new Entry[numBuckets];

        init(); 

        int size = s.readInt();

        for (int i = 0; i < size; i++) {
            K key = (K) s.readObject();
            V value = (V) s.readObject();
            putForCreate(key, value);
        }
    }

    int capacity() {
        return table.length;
    }

    float loadFactor() {
        return loadFactor;
    }
}

Map源码

package java2.util2;

import java.util.Collection;
import java.util.Set;
/**
 * 重构Map接口
 * @author wwl
 *
 * @param <K>
 * @param <V>
 */
public interface Map<K, V> {
    /**
     * 返回map中键值对映射关系的数量
     * 
     * @return
     */
    int size();

    /**
     * 如果此映射不包含键值的映射则返回true
     * 
     * @return
     */
    boolean isEmpty();

    /**
     * 如果此映射包含指定键的映射关系，则返回 true
     * 
     * @param key
     * @return
     */
    boolean containsKey(Object key);

    /**
     * 如果此映射将一个或多个键映射到指定值，则返回 true
     * 
     * @param value
     * @return
     */
    boolean containsValue(Object value);

    /**
     * 指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
     * 允许null键null值
     * @param key
     * @return
     */
    V get(Object key);

    /**
     * 存放键值对
     * 
     * @param key
     * @param value
     * @return
     */
    V put(K key, V value);

    /**
     * 以前与 key 关联的值；如果没有 key 的映射关系，则返回 null。
     * 
     * @param key
     * @return
     */
    V remove(Object key);

    /**
     * 从此映射中移除所有映射关系
     */
    void clear();

    /**
     * 
     * @param m
     */
    void putAll(Map<? extends K, ? extends V> m);

    /**
     * 返回此映射中包含的键的 Set 视图
     * 
     * @return
     */
    Set<K> keySet();

    /**
     * 此映射中包含的值的 collection 视图
     * @return
     */
    Collection<V> values();
    
    /**
     * 此映射中包含的映射关系的 set 视图
     * @return
     */
    Set<Map.Entry<K, V>> entrySet();

    interface Entry<K, V> {
        /**
         * 获取key值
         * @return
         */
        K getKey();

        /**
         * 获取value值
         * @return
         */
        V getValue();

        /**
         * 设置value值
         * @param value
         * @return
         */
        V setValue(V value);
        /**
         * 如果指定的对象等于此映射项，则返回 true
         * @param o
         * @return
         */
        boolean equals(Object o);
        /**
         * 此映射的哈希码值
         * @return
         */
        int hashCode();
    }
    
    /**
     * 如果指定的对象等于此映射，则返回 true
     * @param o
     * @return
     */
    boolean equals(Object o);
    
    /**
     * 此映射的哈希码值
     * @return
     */
    int hashCode();
}

AbstractMap源码

package java2.util2;

import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;




public abstract class AbstractMap<K,V> implements Map<K,V> {
    protected AbstractMap() {
    }

    @Override
    public void clear() {
        entrySet().clear();
    }

    @Override
    public boolean containsKey(Object key) {
        Iterator<Entry<K,V>> i= entrySet().iterator();
        if(key==null){
            while(i.hasNext()){
                Entry<K,V> e=i.next();
                if(e.getKey()==null)
                    return true;
            }
        }else{
            while(i.hasNext()){
                Entry<K,V> e=i.next();
                if(key.equals(e.getKey()))
                    return true;
            }
        }
        return false;
    }

    @Override
    public boolean containsValue(Object value) {
        Iterator<Entry<K,V>> i=entrySet().iterator();
        if(value==null){
            while(i.hasNext()){
                Entry<K,V> e=i.next();
                if(e.getValue()==null)
                    return true;
            }
        }else{
            while(i.hasNext()){
                Entry<K, V> e=i.next();
                if(value==e.getValue())
                    return true;
            }
        }
        return false;
    }

    @Override
    public abstract Set<java2.util2.Map.Entry<K, V>> entrySet();

    @Override
    //允许null键null值
    public V get(Object key) {
        Iterator<Entry<K, V>> i=entrySet().iterator();
        if(key==null){
            while(i.hasNext()){
                Entry<K, V> e=i.next();
                if(e.getKey()==null)
                    return e.getValue();
                
            }
        }else{
            while(i.hasNext()){
                Entry<K, V> e=i.next();
                if(key.equals(e.getKey()))
                    return e.getValue();
            }
        }
        return null;
    }

    @Override
    public boolean isEmpty() {
        return size()==0;
    }
    //volatile也是变量修饰符，只能用来修饰变量。
    //volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。
    //而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。
    //即通过改变就提交实现线程同步
    
    //transient是类型修饰符，只能用来修饰字段。
    //在对象序列化的过程中，标记为transient的变量不会被序列化。
    transient volatile Set<K>        keySet = null;//此处进行定义，表示每次生成set集合都是最新的
    @Override
    public Set<K> keySet() {
        if(keySet==null){
            keySet=new AbstractSet<K>() {
                @Override
                public Iterator<K> iterator(){
                    return new Iterator<K>(){
                        private Iterator<Entry<K, V>> i=entrySet().iterator();
                        
                        public boolean hasNext(){
                            return i.hasNext();
                        }
                        public K next(){
                            return i.next().getKey();
                        }
                        public void remove(){
                            i.remove();
                        }
                    };
                }

                @Override
                public int size() {
                    return AbstractMap.this.size();
                }
                @Override
                public boolean contains(Object k) {
                    return AbstractMap.this.containsKey(k);
                }
            };
        }
        return keySet;
    }

    @Override
    public V put(K key, V value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }

    @Override
    public V remove(Object key) {
        Iterator<Entry<K, V>> i=entrySet().iterator();
        Entry<K, V> correctEntry =null;
        if(key==null){
            while(i.hasNext()){
                Entry<K, V> e=i.next();
                if(e.getKey()==null)
                    correctEntry=e;//让引用指向空引用
            }
        }else{
            while(correctEntry==null&&i.hasNext()){
                Entry<K, V> e=i.next();
                if(key.equals(e.getKey()))
                    correctEntry=e;
            }
        }
        return null;
    }

    @Override
    public int size() {
        return entrySet().size();
    }

    transient volatile Collection<V> values = null;
    
    @Override
    public Collection<V> values() {
        if (values == null) {
            values = new AbstractCollection<V>() {
            public Iterator<V> iterator() {
                return new Iterator<V>() {
                private Iterator<Entry<K,V>> i = entrySet().iterator();

                public boolean hasNext() {
                    return i.hasNext();
                }

                public V next() {
                    return i.next().getValue();
                }

                public void remove() {
                    i.remove();
                }
                        };
                    }

            public int size() {
                return AbstractMap.this.size();
            }

            public boolean contains(Object v) {
                return AbstractMap.this.containsValue(v);
            }
            };
        }
        return values;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj==this)
            return true;
        if(!(obj instanceof Map))
            return false;
        Map<K,V> m=(Map<K, V>) obj;
        if(m.size()!=size())
            return false;
        try {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                K key = e.getKey();
                V value = e.getValue();
                if (value == null) {
                    if (!(m.get(key)==null && m.containsKey(key)))
                        return false;
                } else {
                    if (!value.equals(m.get(key)))
                        return false;
                }
            }
        } catch (ClassCastException unused) {
            return false;
        } catch (NullPointerException unused) {
            return false;
        }

        return true;
    }

    @Override
    //所有map对象的hashcode相加
    public int hashCode() {
        int h = 0;
        Iterator<Entry<K,V>> i = entrySet().iterator();
        while (i.hasNext())
            h += i.next().hashCode();
        return h;
    }

    @Override
    public String toString() {
        Iterator<Entry<K,V>> i = entrySet().iterator();
        if (! i.hasNext())
            return "{}";

        StringBuilder sb = new StringBuilder();
        sb.append('{');
        for (;;) {
            Entry<K,V> e = i.next();
            K key = e.getKey();
            V value = e.getValue();
            sb.append(key   == this ? "(this Map)" : key);
            sb.append('=');
            sb.append(value == this ? "(this Map)" : value);
            if (! i.hasNext())
            return sb.append('}').toString();
            sb.append(", ");
        }
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        AbstractMap<K,V> result = (AbstractMap<K,V>)super.clone();
        result.keySet = null;
        result.values = null;
        return result;
    }
    
}