HashMap 实现总结

1. Entry类中需包含键值的hash值，防止resize时的重复计算；
2. Map容量为2的整幂，可使用位操作取代取余操作提高效率；
3. resize时需要将原table的桶内数据置null，利于垃圾回收；
4. hash函数考虑数据高位的影响，可减少冲突。

public class MyHashMap<K, V> implements IMap<K, V> {
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    static final int DEFAULT_CAPACITY = 16;

    Entry<K, V>[] table;
    int size;
    /**
     * 装载因子
     */
    float loadFactor;
    /**
     * 实际的容量
     */
    int threshold;

    public MyHashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        this.threshold = (int) (DEFAULT_CAPACITY * loadFactor);
        table = new Entry[DEFAULT_CAPACITY];
    }

    public MyHashMap(int initialCapacity, float loadFactor) {
        /**
         * 缺少参数检查
         */
        int capacity = 1;
        while (capacity < initialCapacity) {
            capacity <<= 1;
        }
        this.loadFactor = loadFactor;
        this.threshold = (int) (capacity * loadFactor);
        table = new Entry[capacity];
    }

    public MyHashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * 算术右移，计入高位影响
     */
    static int hash(int h) {
        return h ^ (h >>> 20) ^ (h >>> 12) ^ (h >>> 7) ^ (h >>> 4);
    }

    @Override
    public V put(K k, V v) {
        if (k == null) {
            putForNull(v);
        }
        int hash = hash(k.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            if (e.key.hashCode() == k.hashCode()
                    && (e.key == k || (k != null && k.equals(e.key)))) {
                V oldValue = e.value;
                e.value = v;
                return oldValue;
            }
        }
        addEntry(k, v, i);
        return null;
    }

    private void addEntry(K k, V v, int index) {
        Entry<K, V> e = new Entry<K, V>(k, v, table[index]);
        table[index] = e;
        if (size++ > threshold) {
            resize(table.length * 2);
        }
    }

    void resize(int newCapacity) {
        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int) (newCapacity * loadFactor);
        System.out.println("resize()" + " current capacity: " + table.length);
    }

    void transfer(Entry[] newTable) {
        for (int i = 0; i < table.length; i++) {
            Entry<K, V> e = table[i];
            if (e != null) {
                /**
                 * 需要將原table置为空，方可释放内存
                 */
                table[i] = null;
                do {
                    Entry<K, V> next = e.next;
                    /**
                     * 重复计算hash值，效率不高
                     */
                    int index = indexFor(hash(e.key.hashCode()),
                            newTable.length);
                    e.next = newTable[index];
                    newTable[index] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

    private V putForNull(V value) {
        // 未实现
        return value;
    }

    /**
     * 用位操作取代取余操作，前提是数组长度为2的幂次
     */
    private int indexFor(int hash, int length) {
        return hash & (length - 1);
    }

    @Override
    public V get(K k) {
        int hash = hash(k.hashCode());
        int index = indexFor(hash, table.length);
        Entry<K, V> e = table[index];
        while (e != null) {
            if (e.key.hashCode() == k.hashCode()
                    && (e.key == k || (k != null && k.equals(e.key)))) {
                return e.value;
            }
            e = e.next;
        }
        return null;
    }

    static class Entry<K, V> {
        K key;
        V value;
        Entry<K, V> next;
        int hash;

        public Entry(K k, V v, Entry<K, V> n) {
            key = k;
            value = v;
            next = n;
            // hash = h;
        }

        public V setValue(V v) {
            V oldValue = value;
            value = v;
            return oldValue;
        }

        public boolean equals(Object o) {
            if (!(o instanceof MyHashMap.Entry)) {
                return false;
            }
            Entry e = (Entry) o;
            Object k1 = e.key;
            Object k2 = key;
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = e.value;
                Object v2 = value;
                if (v1 == v2 || (v1 != v2 && v2.equals(v2))) {
                    return true;
                }
            }
            return false;
        }
    }
}