HashCode

如果一个类的对象要用做hashMap的key，那么一定要注意覆盖该类的equals和hashCode方法。

equals()是基类Object的方法，用于判断对象是否有相同地址及是否为同一对象

public boolean equals(Object obj) {
        return (this == obj);
    }

hashCode()是基类Object的native方法，返回int。

hashCode的通用约定：

1.在程序运行期间，只要对象不改变，hashCode方法返回的值始终如一。

2.若两个对象equals方法返回相同，hashCode也应该相同。

3.若两个对象equals方法返回不同，hashCode也应该不同。

根据上面的约定，覆盖hashCode方法时注意：

1.需使用对象属性中关键且独立的部分

2.不要使用equals方法中未使用的属性

3.使用equals方法中使用的属性

String类的hashCode方法：

 public int hashCode() {
         int h = hash;
         if (h == 0 && value.length > 0) {
             char val[] = value;
             for (int i = 0; i < value.length; i++) {
                 h = 31 * h + val[i];
             }
             hash = h;
         }
         return h;
     }

32*d == d<<5   aka   31*d == d<<5-d

一个例子：

----------------------------

 class TestClass {
     // 若类较复杂，建议将hashCode缓存，以提高性能
     private volatile int hashCode = 0;
 
     private int i;
     private boolean b;
     private char c; // 或byte short
     private long l;
     private float f;
     private double d;
     private int[] aa;
     private String s;
 
     @Override
     public boolean equals(Object o) {
         if (o == this) {
             return true;
         }
         if (!(o.getClass() == getClass())) {
             return false;
         }
         TestClass ot = (TestClass) o;
         return i == ot.i && b == ot.b && c == ot.c && l == ot.l && Float.compare(f, ot.f) == 0 && Double.compare(d, ot.d) == 0
                 && Arrays.equals(aa, ot.aa) && s.equals(ot.s);
     }
 
     @Override
     public int hashCode() {
         int result = hashCode;
         if (result == 0) {
             result = 31 * result + i;
             result = 31 * result + Boolean.hashCode(b);
             result = 31 * result + (int)c;
             result = 31 * result + Long.hashCode(l);
             result = 31 * result + Float.hashCode(f);
             result = 31 * result + Double.hashCode(d);
             result = 31 * result + Arrays.hashCode(aa);
             result = 31 * result + s.hashCode();
             hashCode = result;
         }
         return result;
     }
 
     @Override
     public String toString(){
         //略
         return s;
     }
 
 }

----------------------------

HashMap

HashMap默认初始容量16，加载因子0.75，容量也就是内部数组table的大小，总是2的n次方，table中的元素为链表，链表的元素为包含key，value，hash和下一元素的Entry。

put方法根据key的hashCode来计算元素在table中的存放位置，不同的key将均匀的散列在table中。

HashMap的扩容将重新计算所有元素在新数组中的位置，所以如果预计存放大量数据，初始容量应该设置更大。