Java容器_Map_HashMap源码分析

Map是映射：

（1）实现Map接口的类用于存储键(key)--值(Value)对；
（2）Map接口的实现类有HashMap和TreeMap等；
（3）Map类中存储的键值对通过键来标识，所以键值不能重复。

上文已经打开过Map了，定义了一些方法，重要的是定义了一个链表，我们先看看：

  /**     * A map entry (key-value pair).  The <tt>Map.entrySet</tt> method returns     * a collection-view of the map, whose elements are of this class.  The     * <i>only</i> way to obtain a reference to a map entry is from the     * iterator of this collection-view.  These <tt>Map.Entry</tt> objects are     * valid <i>only</i> for the duration of the iteration; more formally,     * the behavior of a map entry is undefined if the backing map has been     * modified after the entry was returned by the iterator, except through     * the <tt>setValue</tt> operation on the map entry.     *     * @see Map#entrySet()     * @since 1.2     */    interface Entry<K,V> {             K getKey();           V getValue();         V setValue(V value);         boolean equals(Object o);            int hashCode();    }

通过说明我们知道这个接口定义了Map的键值对，重写了hashcode和equals方法。

下面打开HashMap的源码，学习一下是如何实现的：

public class HashMap<K,V>    extends AbstractMap<K,V>    implements Map<K,V>, Cloneable, Serializable{    /**     * The default initial capacity - MUST be a power of two.     */    static final int DEFAULT_INITIAL_CAPACITY = 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.     */    static final int MAXIMUM_CAPACITY = 1 << 30;    /**     * The load factor used when none specified in constructor.     */    static final float DEFAULT_LOAD_FACTOR = 0.75f;    /**     * The table, 可扩容. 长度必须是2的整数倍     */    transient Entry<K,V>[] table;    /**     * The number of key-value mappings contained in this map.     */    transient int size;   // 静态内部类，定义了链表   static class Entry<K,V> implements Map.Entry<K,V> {        final K key;        V value;        Entry<K,V> next;        int hash;        /**         * Creates new entry.         */        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 (key==null   ? 0 : key.hashCode()) ^                   (value==null ? 0 : value.hashCode());        }        public final String toString() {            return getKey() + "=" + getValue();        }        /**         * This method is invoked whenever the value in an entry is         * overwritten by an invocation of put(k,v) for a key k that's already         * in the HashMap.         */        void recordAccess(HashMap<K,V> m) {        }        /**         * This method is invoked whenever the entry is         * removed from the table.         */        void recordRemoval(HashMap<K,V> m) {        }    }

接着看put：

   /**     * 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>.)     */    public V put(K key, V value) {        if (key == null)            return putForNullKey(value);        // key对象对应的哈希值        int hash = hash(key);        // 计算键值对应hash在数组table中的索引        int i = indexFor(hash, table.length);        // 遍历指定索引位置的Entry<K,V>对象链表        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))) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }        modCount++;        addEntry(hash, key, value, i);        return null;    }    /**     * 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.     */    void addEntry(int hash, K key, V value, int bucketIndex) {                // 扩容        if ((size >= threshold) && (null != table[bucketIndex])) {            resize(2 * table.length);            hash = (null != key) ? hash(key) : 0;            bucketIndex = indexFor(hash, table.length);        }        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.     */    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++;    }

通过代码，我们可以看出，HashMap是通过数组table和链表Entry<K,V>来实现，通过key对象的Hash，计算分配的数组的位置，然后将对象加入到链表中，数组的当前位置保存最新的对象，这样既实现了数据的方便查询，又实现了链表的方便修改。

最后，在鉴赏鉴赏get方法，写的真好：

   public V get(Object key) {        if (key == null)            return getForNullKey();        Entry<K,V> entry = getEntry(key);        return null == entry ? null : entry.getValue();    }    /**     * Returns the entry associated with the specified key in the     * HashMap.  Returns null if the HashMap contains no mapping     * for the key.     */    final Entry<K,V> getEntry(Object key) {        int hash = (key == null) ? 0 : hash(key);        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;    }