java中HashMap实现原理

1.Hashmap实现的数据结构

 hashmap实现的数据结构是采用数组加链表的方式，它即具有数组的快速查询的寻址特点，又具有链表的删除和添加的快速移动的优点。但是它的效率是介于数组和链表

之间的。实现如图：

hashmap中是以Entry<K,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;
        }

        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;//返回的是之前的Value
        }

        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();
// Key相等且Value相等则两个Entry相等
            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;
        }
        // hashCode是Key的hashCode和Value的hashCode的异或的结果
        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }
        // 重写toString方法，是输出更清晰
        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /**
         *当调用put(k,v)方法存入键值对时，如果k已经存在，则该方法被调用（为什么没有内容？）
         */
        void recordAccess(HashMap<K,V> m) {
        }

        /**
         * 当Entry被从HashMap中移除时被调用（为什么没有内容？）
         */
        void recordRemoval(HashMap<K,V> m) {
        }
    }

hashmap的put()方法：

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);//得到对应key值在数组中的位置，（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.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);//如果不包含key值，则插入到hashmap中
        return null;
    }

hashmap的get()方法：

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());

	//遍历table
        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;
    }

2.hashmap扩容

   当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

   那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。