Effective Java 案例分享(三)

11、重写Object.equals时,必须重写Object.hashcode

如果需要重写Object的equals方法,那么一定要重写hashCode方法, 否则会在哈希表相关的数据结构中出现非常严重的问题。重写hashcode方法也要循环以下几个原则:

  • 在Object的equals的结果未发生改变的情况下,多次调用hashcode方法必须返回一样的结果,如果equals发生了变化,hashCode也要变化;
  • 如果两个对象equals相等,他们的hashCode必须也相等;
  • 如果两个对象equals不相等,不要求一定要返回不用的hashCode,但是不同的hashCode在哈希表中表现可能更好;

推荐重写hashCode方法的步骤:

  1. 声明一个int变量,名称是result;
  2. 通过每一个有效的属性的hashCode,得到变量c。如果该属性是null,hashCode直接等于0,如果是数组,可以使用Arrays.hashCode计算;
  3. 计算结果:result = 31 * result + c;
  4. 返回result;

计算hashCode的经典案例:

@Override 
public int hashCode() {
    int result = Short.hashCode(areaCode);
    result = 31 * result + Short.hashCode(prefix);
    result = 31 * result + Short.hashCode(lineNum);
    return result;
}

为什么要使用31计算hashCode?

选择31作为一个主要的元素,是因为它是奇数。如果它是偶数,多次相乘之后信息会被丢失,因为每一次乘以2都是会左移。如果使用31,它的乘法可以被替换成位移+减法:31 * i = (result << 5)- i;这样hashCode的后几位都可能是非0的,哈希值散步会更均匀;

12、总是重写toString方法

Object的toString方法的默认实现是:Class名称+@+16位hashCode。默认实现的toString方法的可读性并不好,所以我们需要重写toString方法来提供可读性,调试时可以得到更多的可用信息。Object与字符串拼接时,自动使用Obejct的toString方法。

重写toString的要注意的问题:

  • toString应该包含所有的有效信息;
  • toString不仅要输出有效属性的值,也要添加必要的描述,便于理解值的意义;
  • 无论是否要使用特定格式输出String信息,都应该对你关心的问题有清晰的描述;
  • 在制定重写方案之前,要先思考如何从toString中获取想要的信息;

重写toString代码示例:

/**
* Returns the string representation of this phone number.
* The string consists of twelve characters whose format is
* "XXX-YYY-ZZZZ", where XXX is the area code, YYY is the
* prefix, and ZZZZ is the line number. Each of the capital
* letters represents a single decimal digit.
*
* If any of the three parts of this phone number is too small
* to fill up its field, the field is padded with leading zeros.
* For example, if the value of the line number is 123, the last
* four characters of the string representation will be "0123".
*/
@Override 
public String toString() {
    return String.format("%03d-%03d-%04d", areaCode, prefix, lineNum);
}

13、谨慎的重写clone方法

如果一个类可以被克隆,需要实现Cloneable接口,然后重写clone方法。请注意clone方法属于Object,并不属于Cloneable。如果不实现Cloneable接口。调用clone方法会直接跑出异常。

重写clone方法需要注意的地方:

  • 推荐重写clone方法为public;
  • clone方法实现使用super.clone,不要使用new(书中说会编译不过,实测可以运行);
  • 不可复用的class,不要提供clone方法;
  • clone的对象是原始Object的副本,内部的属性对象与原始Object相同,注意使用时对原始对象的影响,可以考虑使用深拷贝(对每一个属性对象都clone一份);
  • clone方法无法修改final的属性对象;
  • 已经实现的clone方法不应该抛出异常;
  • Object的clone方法是线程不安全的,需要自行实现线程安全;

clone方法的缺点:

  • 不会执行构造方法;
  • 拷贝原始对象的所有属性,实际上大部分情况只需要拷贝特定几个属性;
  • 无法修改final属性对象;
  • 如果有唯一标识,要注意clone的时候修改;

使用自定义copy方法,让拷贝更灵活。可以考虑通过构造方法或静态方法等形式拷贝需要的原始对象的内容。例如以下代码:

// Copy constructor
public Yum(Yum yum) { ... };

// Copy factory
public static Yum newInstance(Yum yum) { ... };

使用copy方法的好处:

  • 没有使用变成语言外的方式创建对象(clone使用的是native方法创建对象);
  • 不需要类型的强制转换;
  • 可以修改final对象;
  • 不需要类型检查(clone必须实现Cloneable接口);

14、考虑实现Comparable接口

如果类的对象需要排序,推荐该类实现Comparable接口的compareTo方法。当调用排序方法:

Arrays.sort(a);

数组a会根据实现的Comparable进行排序,这种排序规则是默认的。重写compareTo的规则和重写equals的规则是相似的:

  • x.compareTo(y)) == - y.compareTo(x);
  • x.compareTo(y) > 0 && y.compareTo(z) > 0 , 可得 x.compareTo(z) > 0 ;
  • x.compareTo(y) > 0,可得 x.compareTo(z) == y.compareTo(z);

  • 大于0的正整数,表示排序在前;
  • 0,表示保持目前排序;
  • 小于0的负整数,表示排序在后;

重写compareTo的建议:

  • 如果你想要给一个使用了Comparable的类添加自定义的排序规则,不要继承它,而是用组合的形式,把该类和排序实现的类,组合成一个新的类,这样你可以随时修改排序规则;

  • 强烈推荐(x.compareTo(y) == 0) == (x.equals(y)),如果该判断不成立,要在方法的注释中强调compareTo的结果与equals的结果不一致。一般集合会使用equals判断是否为同一对象,但是排序集合使用的是compareTo。例如以下代码:

val hashSet = HashSet();
val b1 = BigDecimal("1.0");
val b2 = BigDecimal("1.00");
// 因为b1和b2的equals不相等,所以hashSet会保存b1和b2.
hashSet.add(b1);
hashSet.add(b2)

val treeSet = TreeSet();
val b1 = BigDecimal("1.0");
val b2 = BigDecimal("1.00");
// TreeSet内部使用compareTo判断是否相等,BigDecimal内部重写了compareTo方法,
// 所以b1.compareTo(b2) == 0, 即相等,所以treeSet只会有b1.
treeSet.add(b1);
treeSet.add(b2)
  • 在compareTo方法中不要使用and操作,如果你需要判断多个关键的属性,应该按照优先级依次判断。例如下面的代码:
// Multiple-field Comparable with primitive fields
public int compareTo(PhoneNumber pn) {
    int result = Short.compare(areaCode, pn.areaCode);
    if (result == 0) {
        result = Short.compare(prefix, pn.prefix);
            if (result == 0)
                result = Short.compare(lineNum, pn.lineNum);
    }
    return result;
}
  • Java 8 中Comparator提供了更简洁的对比操作,但是在运行速度上Comparable相比
    慢了10%(该数据为作者提供)。应当优先使用Comparator的静态构造方法。例如下面的代码:
// Comparable with comparator construction methods
private static final Comparator<PhoneNumber> COMPARATOR =
            comparingInt((PhoneNumber pn) -> pn.areaCode)
            .thenComparingInt(pn -> pn.prefix)
            .thenComparingInt(pn -> pn.lineNum);
        
public int compareTo(PhoneNumber pn) {
    return COMPARATOR.compare(this, pn);
}
  • 不要在compareTo或者compare方法返回运算的结果,这种写法充满了危险,例如数字的溢出,小数精度等等,应当使用对应类型的compare方法,返回正确的结果。例如下面的代码:
// 错误的写法
static Comparator<Object> hashCodeOrder = new Comparator<>(){
    public int compare(Object o1, Object o2) {
        return o1.hashCode() - o2.hashCode();
    }
};

// 正确的写法1
static Comparator<Object> hashCodeOrder = new Comparator<>(){
    public int compare(Object o1, Object o2) {
        return Integer.compare(o1.hashCode(), o2.hashCode());
    }
};
// 正确的写法2
static Comparator<Object> hashCodeOrder = Comparator.comparingInt(o -> o.hashCode());

推荐阅读更多精彩内容