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;
         }
     }
 }