一.重写equals方法
如果不重写equals，那么比较的将是对象的引用是否指向同一块内存地址，重写之后目的是为了比较两个对象的value值是否相等。
利用equals比较八大包装对象（如int，float等）和String类（因为该类已重写了equals和hashcode方法）对象时，默认比较的是值，在比较其它自定义对象时都是比较的引用地址.
重写规则
(1)自反性: 对于任意的引用值x,x.equals(x)一定为true.
(2)对称性: 对于任意的引用值x和y,当x.equals(y)返回true,y.equals(x)也一定返回true
(3)传递性: 对于任意的引用值x,y和z,如果x.equals(y)返回true,并且y.equals(z)也返回true,那么x.equals(z)也一定返回true
(4)一致性: 对于任意的引用值x和y,如果用于equals比较的对象信息没有被修改,多次调用x.equals(y)要么一致地返回true,要么一致地返回false
(5)非空性: 对于任意的非空引用值x，x.equals(null)一定返回false
重写equals方法修饰符必须是public,因为是重写的Object的方法; 参数类型必须是Object.
重写equals方法后必须重写hashCode方法，否则两个等价对象可能得到不同的hashCode,这在集合框架中使用可能产生严重后果
(1)当obj1.equals(obj2)为true时，obj1.hashCode() == obj2.hashCode()必须为true
(2)当obj1.hashCode() == obj2.hashCode()为false时，obj1.equals(obj2)必须为false
二.重写hashCode方法
hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashCode值来进行判断是否相同的。
通用的hashCode算法实现
1.首先初始化一个整形变量，为此变量赋予一个非零的常数值，比如
int result = 17;
初始值要使用非0的整数,以减少hash冲突.假如所有的域引用都为null,按照下面的算法,采用0作为初始值则计算出来的结果都为0.
2.选取equals方法中用于比较的所有域，然后针对每个域的属性进行计算：
(1) 如果是boolean类型,则计算根据是否为真进行处理,如: f ? 1231 : 1237
(2) 如果是byte\char\short\int类型,则计算(int)f
(3) 如果是long类型,则计算(int)(f ^ (f >>> 32))
(4) 如果是float类型，则计算Float.floatToIntBits(f)
(5) 如果是double类型，则计算Double.doubleToLongBits(f)，然后返回的结果是long,再用规则(3)去处理long,得到int
(6) 如果是对象引用，如果equals方法中采取递归调用的比较方式,那么hashCode中同样采取递归调用hashCode的方式。
否则需要为这个域计算一个范式,比如当这个域的值为null的时候,那么hashCode值为0
(7) 如果是数组,那么需要为每个元素当做单独的域来处理.
如果你使用的是1.5及以上版本的JDK，那么没必要自己去重新遍历一遍数组，java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算，算法同上.
ps:上面所提到的基本元素类型的hashCode计算，其算法同JDK中其包装器类型所覆盖的hashCode逻辑一致，具体如下
java.lang.Long的hashCode实现:
public int hashCode() {
return (int)(value ^ (value >>> 32));
}
java.lang.Float的hashCode实现:
public int hashCode() {
return floatToIntBits(value);
}
java.lang.double的hashCode实现:
public int hashCode() {
long bits = doubleToLongBits(value);
return (int)(bits ^ (bits >>> 32));
}
java.lang.boolean的hashCode实现
public int hashCode() {
return value ? 1231 : 1237;
}
其它类型,可按如下实现
java.lang.byte的hashCode实现,char\short\int同理也可按此实现
public int hashCode() {
return value;
}
3.将上述hashCode值与质数因子进算得到新的值
result = result * 31 + hashCode();
4.此算式的几点解释:
使用乘法去操作result: 目的是为了使散列值依赖于域的顺序.如同时包含了两个相同类型的域,以保证顺序不同产生不同的hashCode.
使用31作为质数因子: 31是个神奇的数字,因为任何数n * 31就可以被JVM优化为(n << 5) - n, 移位和减法的操作效率要比乘法的操作效率高的多.
三.一个具体的实现类的例子
class Item {
private String mName;
private long mId;
private long mValue;
public Item(String name, long id) {
mName = name;
mId = id;
}
public Item(String name, long id, long value) {
mName = name;
mId = id;
mValue = value;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!(obj instanceof Item))
return false;
Item object = (Item) obj;
if (mName == null) {
if (object.mName != null)
return false;
} else if (!mName.equals(object.mName)) {
return false;
}
if (mId != object.mId)
return false;
if (mValue != object.mValue)
return false;
return true;
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + (mName != null ? mName.hashCode() : 0);
result = 31 * result + (int) (mId ^ (mId >>> 32));
result = 31 * result + (int) (mValue ^ (mValue >>> 32));
return result;
// HashCodeBuilder builder = new HashCodeBuilder();
// builder.append(mId).append(mName).append(mValue);
// return builder.getHashCode();
}
@Override
public String toString() {
return "Item[mName=" + mName + ", mId=" + mId + ", mValue=" + mValue
+ "]";
}
}
四.一个hashCode生成器类
/**
* hashCode生成器
*/
public class HashCodeBuilder { private final int mMultiplierFactor;
private int mHashCode; public HashCodeBuilder() {
this(17, 31);
} public HashCodeBuilder(int initialCode) {
this(initialCode, 31);
} public HashCodeBuilder(int initialCode, int multiplierFactor) {
mHashCode = initialCode;
mMultiplierFactor = multiplierFactor;
} public int getHashCode() {
return mHashCode;
} public HashCodeBuilder append(int[] array) {
for (int element : array) {
append(element);
}
return this;
} public HashCodeBuilder append(byte[] array) {
for (byte element : array) {
append(element);
}
return this;
} public HashCodeBuilder append(short[] array) {
for (short element : array) {
append(element);
}
return this;
} public HashCodeBuilder append(char[] array) {
for (char element : array) {
append(element);
}
return this;
} public HashCodeBuilder append(long[] array) {
for (long element : array) {
append(element);
}
return this;
} public HashCodeBuilder append(float[] array) {
for (float element : array) {
append(element);
}
return this;
} public HashCodeBuilder append(double[] array) {
for (double element : array) {
append(element);
}
return this;
} public HashCodeBuilder append(boolean[] array) {
for (boolean element : array) {
append(element);
}
return this;
} public HashCodeBuilder append(int element) {
mHashCode = mHashCode * mMultiplierFactor + element;
return this;
} public HashCodeBuilder append(byte element) {
mHashCode = mHashCode * mMultiplierFactor + element;
return this;
} public HashCodeBuilder append(short element) {
mHashCode = mHashCode * mMultiplierFactor + element;
return this;
} public HashCodeBuilder append(char element) {
mHashCode = mHashCode * mMultiplierFactor + element;
return this;
} public HashCodeBuilder append(long element) {
mHashCode = mHashCode * mMultiplierFactor
+ ((int) (element ^ (element >>> 32)));
return this;
} public HashCodeBuilder append(float element) {
return append(Float.floatToIntBits(element));
} public HashCodeBuilder append(double element) {
return append(Double.doubleToLongBits(element));
} public HashCodeBuilder append(boolean element) {
mHashCode = mHashCode * mMultiplierFactor + (element ? 1231 : 1237);
return this;
} /**
* 处理自定义类型元素或数组
* @param object,数组或一个元素
* @return
*/
public HashCodeBuilder append(Object object) {
if (object == null)
return appendNull(); Class<?> klassType = object.getClass().getComponentType();
// klass为null,表示一个元素,否则表示一个数组
if (klassType == null) {
return appendElement(object);
}
return deepHashCode((Object[])object);
} private HashCodeBuilder deepHashCode(Object[] array) {
if (array == null) {
return appendNull();
}
for (Object element : array) {
deepHashCodeElement(element);
}
return this;
} private HashCodeBuilder deepHashCodeElement(Object element) {
if (element == null) {
return appendNull();
} Class<?> klass = element.getClass().getComponentType(); // klass为null,表示一个元素,否则表示一个数组
if (klass == null) {
return appendElement(element);
} // isPrimitive返回true则为基本类型,如 int\char\...等
if (!klass.isPrimitive()) {
return deepHashCode((Object[]) element);
} if (klass.equals(int.class)) {
return append((int[]) element);
}
if (klass.equals(char.class)) {
return append((char[]) element);
}
if (klass.equals(boolean.class)) {
return append((boolean[]) element);
}
if (klass.equals(byte.class)) {
return append((byte[]) element);
}
if (klass.equals(long.class)) {
return append((long[]) element);
}
if (klass.equals(float.class)) {
return append((float[]) element);
}
if (klass.equals(double.class)) {
return append((double[]) element);
}
return append((short[]) element);
} private HashCodeBuilder appendElement(Object element) {
if (element == null)
return appendNull(); Class<?> klass = element.getClass(); // klass 对于基本类型将自动包装
if (klass.equals(Integer.class)) {
int value = (Integer) element;
return append(value);
} if (klass.equals(Character.class)) {
char value = (Character) element;
return append(value);
} if (klass.equals(Boolean.class)) {
boolean value = (Boolean) element;
return append(value);
} if (klass.equals(Byte.class)) {
byte value = (Byte) element;
return append(value);
} if (klass.equals(Short.class)) {
short value = (Short) element;
return append(value);
} if (klass.equals(Long.class)) {
long value = (Long) element;
return append(value);
} if (klass.equals(Float.class)) {
float value = (Float) element;
return append(value);
} if (klass.equals(Double.class)) {
double value = (Double) element;
return append(value);
} // 非基本类型元素,调用其自身的hashCode方法进行计算
mHashCode = mHashCode * mMultiplierFactor + element.hashCode();
return this;
} /**
* 处理null值对象
* @return
*/
private HashCodeBuilder appendNull() {
mHashCode = mHashCode * mMultiplierFactor + 0;
return this;
}
}