Effective Java2读书笔记-对于所有对象都通用的方法（一）

第8条：覆盖equals时请遵守通用约定

①约定的内容

• 自反性。对于任何非null的引用值x。x.equals(x)必须返回true。
• 对称性。对于任何非null的引用值x和y。当且仅当y.equals(x)返回true时，x.equals(y)必须返回true。
• 传递性。对于任何非null的引用值x、y和z，如果x.equals(y)返回true，并且y.equals(z)也返回true，则x.equals(z)也必须是true。
• 一致性。对于任何非null的引用值x和y，只要equals的比较操作在对象中所用的信息没有被修改，多次调用x.equals(y)就会一致的返回true或者一致返回false。
• 非空性。对于任何非null的引用值x，x.equals(null)必须返回false。

书中举了两个例子，主要是针对对称性和传递性。下面先看一下对称性的反例。

public final class CaseInsensitiveString {
    private final String s;

    public CaseInsensitiveString(String s) {
        if (s == null)
            throw new NullPointerException();
        this.s = s;
    }
    @Override
    public boolean equals(Object o) {
        if (o instanceof CaseInsensitiveString)
            return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
        if (o instanceof String)
            return s.equalsIgnoreCase((String) o);
        return false;
    }

    public static void main(String[] args) {
        CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
        String s = "polish";
        System.out.println(cis.equals(s) + "  " + s.equals(cis));
    }
}

该例子人为封装了一个不区分大小写的字符串类。其中，equals方法传入普通字符串时，也是可以比较的。但是反过来，普通字符串调用equals方法传入CaseInsensitiveString类型的字符串，就返回false了（相信实际中没人会这么用，这里只是给大家提个醒）。

下面再看一个传递性的反例。

点类，横纵坐标都相等即认为是相等

//点类
public class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Point))
            return false;
        Point p = (Point) o;
        return p.x == x && p.y == y;
    }

    @Override
    public int hashCode() {
        return 31 * x + y;
    }
}

带颜色的点类，横纵坐标都相等，且颜色也相同就认为是相等

public class ColorPoint extends Point {
    private final Color color;

    public ColorPoint(int x, int y, Color color) {
        super(x, y);
        this.color = color;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof ColorPoint))
            return false;
        return super.equals(o) && ((ColorPoint) o).color == color;
    }

    public static void main(String[] args) {
        ColorPoint p1 = new ColorPoint(1, 2, Color.RED);
        Point p2 = new Point(1, 2);
        ColorPoint p3 = new ColorPoint(1, 2, Color.BLUE);
        System.out.printf("%s %s %s%n", p2.equals(p1), p2.equals(p3),
                p1.equals(p3));
    }
}

public enum Color {
    RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
}

这时，p2.equals(p1)是true，p2.equals(p3)也是true，但是p1.equals(p3)是false，不符合传递性。归根结底的原因是p2是基类生成的对象，p1和p3是子类生成的对象。因此，p2和p1、p3比较时，就变色盲了。

②实现高质量equals方法的诀窍。

• 首先使用“==”操作符检查传入的是否是这个对象的引用。
• 然后使用Instanceof操作符检查“参数类型是否正确”。
• 把Object强转为正确的类型再进行一系列比较。
• 当编写完后，注意对称性和传递性。
• 注意，一定要覆盖Object类中equals方法，不要重写成equals(MyClass o)。

第9条：覆盖equals时总要覆盖hashCode

首先看一个例子，它完全是根据第8条的诀窍写出来的。

public final class PhoneNumber {
    private final short areaCode;
    private final short prefix;
    private final short lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        rangeCheck(areaCode, 999, "area code");
        rangeCheck(prefix, 999, "prefix");
        rangeCheck(lineNumber, 9999, "line number");
        this.areaCode = (short) areaCode;
        this.prefix = (short) prefix;
        this.lineNumber = (short) lineNumber;
    }

    private static void rangeCheck(int arg, int max, String name) {
        if (arg < 0 || arg > max)
            throw new IllegalArgumentException(name + ": " + arg);
    }

    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof PhoneNumber))
            return false;
        PhoneNumber pn = (PhoneNumber) o;
        return pn.lineNumber == lineNumber && pn.prefix == prefix
                && pn.areaCode == areaCode;
    }

    public static void main(String[] args) {
        Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();
        m.put(new PhoneNumber(707, 867, 5309), "Jenny");
        System.out.println(m.get(new PhoneNumber(707, 867, 5309)));
    }
}

但是，返回结果却不是Jenny，而是null。这是由于PhoneNumber类没有覆盖hashCode方法，从而导致两个相等的实例具有不相等的散列码，违反了hashCode的约定，因此put方法把电话号码对象存放在一个散列桶中，get方法却在另一个散列桶中查找电话号码。即使凑巧放到一个桶中，get仍然返回null，因为HashMap有一项优化，如果散列码不匹配，直接不检验对象的等同性了。

修正问题的办法就是提供一个hashCode方法。例如

@Override
public int hashCode(){return 42;}

它确保了相同的对象总是有同样的散列码。但它也是极为恶劣的，因为它使得每一个对象都有同样的散列码。这样，所有的对象都会被放到同一个散列桶中，使得散列退化成了链表。理想情况下，散列函数应该把集合中不相等的实例均匀地分布到所有可能的散列值上。

对于不同的域（上述例子是3个short），有一套不同的计划散列码的规则。好在Eclipse已经可以帮我们自动生成了。

至于为什么要使用31这个数字，博文http://blog.csdn.net/mingli198611/article/details/10062791给出了分析

A.31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终的出来的结果只能被素数本身和被乘数还有1来整除！。(减少冲突)

B.31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化.（提高算法效率）

C.选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）

D.并且31只占用5bits,相乘造成数据溢出的概率较小。