Java 覆盖equals和hashCode方法
Java 覆盖equals和hashCode方法
wuxinshui 发表于9个月前
Java 覆盖equals和hashCode方法
  • 发表于 9个月前
  • 阅读 3
  • 收藏 0
  • 点赞 0
  • 评论 0

前言

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

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

覆盖equals

覆盖equals方法时,必须遵守它的通用约定,如果你违反了它们,就会发现你的程序将表现不正常,甚至奔溃,而且很难找到失败的根源。

通用约定

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

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

这里写图片描述

实现高质量equals方法的诀窍

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

示例

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));
    }
共有 人打赏支持
粉丝 3
博文 52
码字总数 28324
×
wuxinshui
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: