Java 覆盖equals和hashCode方法

用户2146693

发布于 2019-08-08 15:10:17

8050

发布于 2019-08-08 15:10:17

文章被收录于专栏：架构师进阶架构师进阶

前言

覆盖equals方法看起来似乎很简单，但是有许多覆盖方式会导致错误，并且后果非常严重，最容易避免这类问题的办法就是不覆盖equals方法。

什么时候需要覆盖equals方法？如果类具有自己特有的“逻辑相等”概念（不同于对象等同），而且超类还没有覆盖equals方法以实现期望的行为，这时需要覆盖equals方法。

覆盖equals

覆盖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。

一般IDE工具，如IntelliJ IDEA可以帮助实现equals方法覆盖。基本上是符合以上约定的。

实现高质量equals方法的诀窍

使用==操作符检查“参数是否为这个对象的引用”。
使用instanceof操作符检查“参数是否为正确的类型”。
把参数转化为正确的类型。
对于该类的中每个关键域，检查参数中的域是否与该对象中对应的域想匹配。

示例

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 obj) {
        if (this==obj) return true;
        if (!(obj instanceof Point)) {
            return false;
        }
        Point p = (Point) obj;
        return p.x == x && p.y == y;
    }
}

类型检查为什么不用getClass()

getClass测试代替instanceof 测试，只有当对象有相同的实现时，才能使对象等同。此外，使用instanceof 还可以省去对null的判断。

    @Override
    public boolean equals(Object obj) {
        if (this==obj) return true;
        if (obj==null || this.getClass()!=obj.getClass()) return false;
        Point p = (Point) obj;
        return p.x == x && p.y == y;
    }

Point1,Point2继承Point。

    public static void point1ComparePoint2(){
        Point point1=new Point1(1,2);
        Point point2=new Point2(1,2);
        Point point3=new Point2(1,2);

        //不同实现的比较
        System.out.println(point1.equals(point2));
        System.out.println(point2.equals(point1));

        //相同实现的比较
        System.out.println(point2.equals(point3));

    }

运行结果： false false true

覆盖hashCode方法

重写equals方法必须要重写hashCode方法。如果不这样做的话会违反Object.hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常运作。如HashMap、HashTable、HashSet。

    public static void pointListCompare(){
        Point point1=new Point(1,2);
        Point point2=new Point(1,2);
        Map<Point,String> mp=new HashMap<>();
        mp.put(point1,"Point1");
        System.out.println("point1==point2 "+(point1==point2));
        System.out.println("point1 hashCode is:"+(point1.hashCode()));
        System.out.println("point2 hashCode is:"+(point1.hashCode()));
        System.out.println(mp.containsKey(point1));
        System.out.println(mp.containsKey(point2));
    }

运行结果： point1==point2 false point1 hashCode is:2133927002 point2 hashCode is:1836019240 true false

Point中添加hashCode()方法

    @Override
    public int hashCode() {
        //31是一个奇素数，有个很好的特性，乘法可以优化为移位和减法：31*i==(i<<5)-i。
        // 现在的VM可以自动完成这种优化。习惯上都使用素数来计算散列结果
        int result = x;
        result = 31 * result + y;
        return result;
    }

运行结果： point1==point2 false point1 hashCode is:33 point2 hashCode is:33 true true

HaspMap有一项优化，可以将与每个项相关联的散列码缓存起来，如果散列码不匹配，也不必检验对象的等同性。

完美实例

不同类型的覆盖方法和hashCode生成。

public class PerfectEquals {
    //基本类型
    private int x;
    private char c;
    private double d;
    private float f;
    private String name;//引用类型
    private Color color;//枚举类型
    private Point point;//引用类型
    private List<Point> pointList;//集合类


    public PerfectEquals(int x, char c, double d, float f, String name, Color color, Point point, List<Point> pointList) {
        this.x = x;
        this.c = c;
        this.d = d;
        this.f = f;
        this.name = name;
        this.color = color;
        this.point = point;
        this.pointList = pointList;
    }

    @Override
    public boolean equals(Object o) {
        //1. 使用==操作符检查“参数是否为这个对象的引用”。
        if (this == o) return true;
        //2. 使用instanceof操作符检查“参数是否为正确的类型”。
        if (!(o instanceof PerfectEquals)) return false;
        //3. 把参数转化为正确的类型。
        PerfectEquals that = (PerfectEquals) o;

        //4. 对于该类的中每个关键域，检查参数中的域是否与该对象中对应的域想匹配。
        if (x != that.x) return false;
        if (c != that.c) return false;
        if (Double.compare(that.d, d) != 0) return false;
        if (Float.compare(that.f, f) != 0) return false;
// if (name != null ? !name.equals(that.name) : that.name != null) return false;//10000000 times compare cost time is 27-32ms
        if (name!=that.name|| name!=null&&!name.equals(that.name)) return false;//更快些，10000000 times compare cost time is 3-4ms
        if (color != that.color) return false;
// if (point != null ? !point.equals(that.point) : that.point != null) return false;
        if (point!=that.point||point!=null&&!point.equals(that.point)) return false;
// return pointList != null ? pointList.equals(that.pointList) : that.pointList == null;
        return pointList==that.pointList|| pointList!=null&&pointList.equals(that.pointList);
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = x;
        //31是一个奇素数，有个很好的特性，乘法可以优化为移位和减法：31*i==(i<<5)-i。
        // 现在的VM可以自动完成这种优化。习惯上都使用素数来计算散列结果
        result = 31 * result + (int) c;
        temp = Double.doubleToLongBits(d);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        result = 31 * result + (f != +0.0f ? Float.floatToIntBits(f) : 0);
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (color != null ? color.hashCode() : 0);
        result = 31 * result + (point != null ? point.hashCode() : 0);
        result = 31 * result + (pointList != null ? pointList.hashCode() : 0);
        return result;
    }

    public static void main(String[] args) {
        List<Point> pointList=new ArrayList<>();
        Point point1=new Point(1,2);
        Point point2=new Point(2,2);
        Point point3=new Point(3,2);
        pointList.add(point1);
        pointList.add(point2);
        pointList.add(point3);

        PerfectEquals pe1=new PerfectEquals(12,'c',12D,21f,"Perfect",Color.RED,new Point(23,24),pointList);
        PerfectEquals pe2=new PerfectEquals(12,'c',12D,21f,"Perfect",Color.RED,new Point(23,24),pointList);

        long start=System.currentTimeMillis();
        for (int i=0;i<10000000;i++){
            pe1.equals(pe2);
        }
        long end=System.currentTimeMillis();
        System.out.println("compare cost time is :"+(end-start));
    }

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法

面向对象编程

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

编程算法

面向对象编程

登录后参与评论

0 条评论

热度