Java基础系列---hashmap

hashmap 属于Java集合中经常使用的一种数据结构，他是一种快存快取的数据结构。如何实现快素存取是重点。我们都知道 数组 是一种寻址快速，插入 修改较慢的数据结构，链表刚好相反，寻址慢，插入，修改快。而hashmap综合了两者的特性。本文参照JDK1.6进行分析介绍hashmap的实现原理，如何保证快存快取。

1.什么是hashmap
hashmap首先是用一个数组实现的，每个数组内部存储的是Entry，我们往map中存放元素和取出元素实际上是从这个数组中存放和取出的。

    /**
     *  存储数据的 table ，也就是hashmap最主要的table ，其中存储的是node.
     */
    transient com.sjjg.hashmap.Node<K,V>[] table;

这里源码中的node是实现了Entry 接口的，每个Entry 内部都维护了下一个Entry的引用，因此组成了一个Entry的链表结构。
源码如下：

 /**
         hashmap 中维护了一个ENTRY的链表，这是链表的节点
            node 是实现了Map.Entry<K,V> 的静态内部类
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        //这里维护了一个指向下一个节点的引用
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }
        //重写的hashCode.
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        //重写的equals
        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                //这里实际上使用的是 key 和value 内部的equals方法进行比较
                if (Objects.equals(key, e.getKey()) &&
                        Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

所有hashmap形成了如下的数据结构。

2.如何保证快速存

hashmap中元素的存是一个个的键值对，当我们调用put(k,v);方法的时候hashmap有如下几个步骤：
①计算键值对 中key的哈希值，通过哈希值再经过一系列计算获取key需要存储在entry数组table的那个位置。也就是数组table的下标。
②判断这个位置是否已经存在元素，如果没有直接存，如果有，判断是否key相等，如果相等覆盖之前的value值。如果不相等那么就把之前该位置上的元素往下移动，这个移动非常快速，就是把新加元素的指针指向原有元素。

3.如何保证快速取
hashmap要想取出某个元素需要先定位该元素，定位是通过key的hash值计算出key所属的entry在table数组中的那个位置上，通过数组下标快速定位该位置，因为该位置存放的是entry链表的头，从entry链表的头开始遍历，判断entry中是否有key的值和当前传入的key相等（这里相等是通过key的equals方法判断），如果有，拿到entry的value值返回，如果没有则返回空。

4.源码分析

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;

    /**
     * 存储数据的table 我们的键值对都放在这里面，table的长度保证是2的N次方
     */
    transient Entry[] table;

    /**
     * 有多少个键值对
     */
    transient int size;

    /**
     * 下一次需要扩容的 键值对的数量.
     */
    int threshold;

    /**
     * 当前map的容量因子
     */
    final float loadFactor;

    /**
     * map被修改过的次数
     */
    transient volatile int modCount;

    /**
     * 通过容量因子和容量构造map
     */
    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);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * 默认的hashmap 容量16 因子0.75
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

    /**
     * 通过map构造一个map ，传入的map若为空则会出现空指针
     */
    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);
    }

    /**
     * 遍历 传入的map。拿到每个entry的key和value 往table中放。
     */
    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());
        }
    }
    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;
            if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k)))) {
                e.value = value;
                return;
            }
        }
        createEntry(hash, key, value, i);
    }
    //给table 中的位置 赋值 
    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++;
    }

    /**
     * 可以认为是构造完成map的回调
     */
    void init() {
    }

    /**
     * 哈希算法，通过哈希来进行散列，尽量保证不碰撞
     */
    static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    /**
     * 根据哈希值和table的长度获取table的下标值
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

    /**
     * map中有多少个键值对
     */
    public int size() {
        return size;
    }

    /**
     * 是否空
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 取值的方法
     */
    public V get(Object key) {
        //如果key是空那么就存空
        if (key == null)
            return getForNullKey();
        //根据key通过哈希算出哈希值
        int hash = hash(key.hashCode());
        //根据哈希值拿到下标，得到该位置的entry
        //变量该位置的所有entry，遍历判断每个的key的哈希值是否相同
        // 以及key是否相等这里判断是使用key 的 equals方法或者key的地址值进行判断的
        //存在相等的返回 value，不存在返回null、
        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为空的值是存在于table的第一个位置，如果
     * 这个位置没有那么就返回空
     */
    private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

    /**
     * 是否包含某个KEY
     */
    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    /**
     * 返回key对应的entry的值，如果没有返回空 
     */
    final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        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;
    }

    /**
     * 存值
     */
    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
       // 计算key的哈希值
        int hash = hash(key.hashCode());
        //根据哈希值算出key所在table中哪个位置 I
        int i = indexFor(hash, table.length);
        //遍历 entry 链表 判断是否key已经存在，若存在则替换value，并且返回旧的value
        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++;
        //若key是新的值添加entry
        //在这里 还进行了是否扩容的判断
        addEntry(hash, key, value, i);
        //返回空 说明添加成功
        return null;
    }

    /**
     * 存空值的方法
     */
    private V putForNullKey(V value) {
        //遍历table第一个位置中的链表，如果有空值的key那么替换之前的value返回旧的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;
    }

    /**
     *添加新键值对
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
        //获取bucketIndex 位置旧的键值对
        Entry<K,V> e = table[bucketIndex];
        //创建新的键值对，传入了旧的键值对 。这里在新的键值对中 有引用指向旧的键值对
        //相当于在链表 头部增加一个 entry
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        //判断size 是否大于等于 需要扩容的数量，如果是进行扩容
        if (size++ >= threshold)
            resize(2 * table.length);
    }

    /**
     * 扩容操作 传入新的容量
     */
    void resize(int newCapacity) {
        //获取旧的table 和长度
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        //判断是否是最大长度，如果是下次扩容的数量是INT 最大值
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        //创建一个新的大小的数组
        Entry[] newTable = new Entry[newCapacity];
        //重新进行散列计算，把旧的键值对entry放入新的table数组中
        transfer(newTable);
        //table指向新的table
        table = newTable;
        //记录下次需要扩容的数量
        threshold = (int)(newCapacity * loadFactor);
    }
    /**
     * 重新进行散列计算，把旧的键值对entry放入新的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);
            }
        }
    }