HashMap简单实现

HashMap

HashMap可以看成是一个 `数组+链表/红黑树` 组合成的数据结构。

HashMap，HashTable，ConcurrentHashMap是基于hash表的实现，HashTable和HashMap在代码实现上，基本上是一样的，一个是线程安全的，一个非线程安全。ConcurrentHashMap也是线程安全的，但性能比HashTable好。

重要点

在hashMap中放入（put）元素，有以下重要步骤：

• 计算key的hash值，获得元素在底层数组中的下标。

• 通过下标位置定位到底层数组里的元素。

• 取到第一个元素，判断放入元素的key和当前位置的key是否==或者equals，成立则替换value值，返回旧值。

• 如果是树，循环树中的节点，判断放入元素的key和当前节点的key是否==或者equals，成立则替换树里的value，并返回旧值，不成立就添加到树里。

• 第一个元素不匹配就顺着元素的链表结构循环节点，判断放入元素的key是否==或equals节点的key，成立则替换链表里value，并返回旧值，找不到就添加到链表的最后。

判断放入HashMap中的元素要不要替换当前节点的元素，key满足以下两个条件即可替换：

• 1、hash值相等。

• 2、==或equals的结果为true。

由于hash算法依赖于对象本身的hashCode方法，所以对于HashMap里的元素来说，hashCode方法和equals方法非常重要，所以equals方法和hashCode方法一般是绑定重写的, 否则会造成hashMap运行结果不正确！

几个常量

    static final float DEFAULT_LOAD_FACTOR = 0.75f; //负载因子    transient int size; //逻辑长度    transient int modCount; //修改次数, 用于fail-fast    int threshold; //阈值，用于扩容，一般等于 （loadFactor * capacity）    //没有空数组初始化会造成空指针异常    static final Node<?,?>[] EMPTY_TABLE = {};    //HashMap的主干数组，就是一个Node数组，初始值为空数组{}，主干数组的长度一定是2的次幂。     transient Node<K,V>[] table = (Node<K,V>[]) EMPTY_TABLE;     static final int TREEIFY_THRESHOLD = 8; //链表红黑树转换阈值

数组元素

数组里原对象是Node。

static class Node<K，V> implements Map.Entry<K，V>{    final int hash; //hash值    final K key;    V value;    Node<K，V> next; //指向下一个Node的引用，组成链表结构    Node(int hash, K key, V value, Node<K,V> next) {         //...省略构造函数    }   } 

添加Key-Value对

public V put(K key, V value){    return putVal(hash(key), key, value, false, true);}

计算hash值

static fianl int hash(Object key){    int h;    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);  //高低位优化，降低碰撞几率}

添加到链表

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {    Node<K,V>[] tab; Node<K,V> p; int n,i;    /**添加元素时table为空，触发resize（）**/    if((tab = table)==null || (n = table.length) == 0)         n = (tab.resize()).length;    /** 添加元素时 @if tab[i]位置上没有元素，直接添加      * n为table的逻辑长度，即size      * i = (n - 1) & hash 算法可以保证 i 在 n-1 和 hash 之间      * @else 遍历 通过equals和==判断链表上key和hash是否和目标相同，      * 是则替换，否则添加至链表尾部     **/     //1。从底层数组取值     if((p = tab[i = (n - 1) & hash]) == null)        tab[i] = newNode(hash, key, value, null);  //数组元素转成一个单向链表       else{        Node<K,V> e; K k;        //2。底层数组元素匹配成功，赋值给e        if((hash == p.hash) &&             ((k = p.key) == key || (key != null && key.equals(k)))        e = p;         //3。树结构处理        else if (p instanceof TreeNode)            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);        //4。底层数组第一个没匹配上，遍历查询匹配        else {            for (int binCount = 0; ; ++binCount) {                //添加元素到尾部                if ((e = p.next) == null) {                    p.next = newNode(hash, key, value, null);                    if (binCount >= TREEIFY_THRESHOLD - 1) //链表元素大于阈值                        treeifyBin(tab, hash); //转成红黑树                    break;                }                //同2。                if (e.hash == hash &&                    ((k = p.key) == key || (key != null && key.equals(k)))                    break;                p = e;            }        }        //替换value        if (e != null) {            V oldValue = e.value;            if (!onlyIfAbsent || oldValue == null)                e.value = value;            afterNodeAccess(e);            return oldValue;        }    }    ++modCount;    if (++size > threshold)        resize();    afterNodeInsertion(evict);    return null;}

添加到树

//more code here

扩容

hashMap的扩容由resize方法实现, 这个resize方法只是简单实现, 不是源码.

    private Node<K, V>[] resize() {        int newCap = 0;        //数组为空,初始化一个数组        if (table.length == 0 || table == null){            newCap = DEFAULT_INITIAL_CAPACITY;            Node<K,V>[] newTab = (Node<K,V>[]) new Node[ newCap ];            table = newTab;            return newTab;        }        //数组逻辑长度超过阈值,扩容并复制原数组,数组长度要保证是2的幂次数.        else if (size >= (threshold = (int) (loadFactor * table.length))){            newCap = table.length * 2;                Node<K,V>[] newTab = (Node<K,V>[]) new Node[ newCap ];            transfer(newTab);            table = newTab;            return newTab;        }        //超过最大长度        else if (size > MAXIMUN_CAPACITY){            newCap = HashMap2.MAXIMUN_CAPACITY;            return table;        }        return null;    }    /**     * 把原数组的元素传到扩容后的数组     */    void transfer(Node[] newTable) {        int newCapacity = newTable.length;        for (Node<K,V> e : table) {            while(null != e) {                Node<K,V> next = e.next;                int i = e.hash & (newCapacity - 1);                e.next = newTable[i];                newTable[i] = e;                e = next;            }        }    }