Android开发技术分享

Effective Java 案例分享（三）

2022-01-06  本文已影响0人  珠穆朗玛小王子

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

如果需要重写Object的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代码示例：

/**
* 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方法的缺点：

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

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

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

使用copy方法的好处：

14、考虑实现Comparable接口

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

Arrays.sort(a);

数组a会根据实现的Comparable进行排序，这种排序规则是默认的。重写compareTo的规则和重写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)

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

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

// 错误的写法
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());
上一篇下一篇

猜你喜欢

热点阅读