如何写好 Java equals 方法

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量730 收藏 2
点赞数 1
分类专栏： Java进阶 文章标签： java equals
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwlove5280/article/details/109357674
版权

文章目录

前言

equals 方法是面试中一个常客，我以前面试的时候，被人问了一些比较刁钻的问题，但是我回答的并不是很好。这篇文章就对 equals 方法进行一个全方位的分析与总结。

操作符==

操作符 == 也是用于比较两个对象，如果比较的是基本类型，那么比较是对象的值，例如

int a = 10;
int b = 11;
System.out.println("a == b? = " + (a == b)); // false

如果比较的是引用类型，那么比较的是引用所指向的对象的地址，也就是说，比较两个引用是否指向相同的对象，例如

Hello h1 = new Hello();
Hello h2 = new Hello();
Hello h3 = h1;
System.out.println("h1 == h2? " + (h1 == h2)); // false
System.out.println("h1 == h3? " + (h1 == h3)); // true

equals 方法

equals 方法属于 Object 类，它默认是使用操作符==进行比较，如下

    public boolean equals(Object obj) {
        return (this == obj);
    }

也就是说，如果不覆盖 Object 类中的 equals 方法，那么 equals 方法默认就是比较引用是否指向相同的对象。

为什么要覆写equals方法

并不是所有时候都需要覆写equals方法，那么什么时候需要呢？我想，大部分情况是为了配合Java集合来使用。例如有下面一个引用类

public class Person {
	private String name;
	private int age;
	public Person(String name, int age) {
		this.name = Objects.requireNonNull(name);
		this.age = age;
	}
}

再往集合中添加一个 Person 对象，如下

List<Person> list = new ArrayList<>();
list.add(new Person("david", 11));

那么 list.contains(new Person("david",11)) 返回的却是 false，因为 ArrayList 的 contains 方法使用 equals 方法判断两个对象是否相等，而 Person 类没有覆盖这个方法，因此比较的是两个引用是否指向同一个对象，很显然，这不相等。

然而实际的情况中，我们希望两个 Person 对象，通过 equals 方法比较返回 true，这就是所谓的逻辑相等。因此，在需要的时候，我们有必须覆盖 equals 方法。

equals 约定

在 Object 类的源码中，我们可以看到 equals 方法的注释中，列举了覆写 equals 需要遵守的约定，如下

  1. 自反性 : 对于任何非空的引用值 x，x.equals(x) 应该返回 true。
  2. 对称性 : 对于任何非空的引用值 x 和 y，如果 x.equals(y) 返回 true，那么 y.equals(x)也应该返回 true。
  3. 传递性 : 对于任何非空引用值 x, y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 也应该返回 true。
  4. 一致性 : 对于任何非空应用值 x 和 y，如果在 equals 方法中所使用的对象的信息没有被修改，那么多次调用 x.equals(y) 必须返回相同的结果。
  5. 非空性 : 对于任何非空引用值 x，x.equals(null) 应该返回 false。

这些理论只是我们不需要去证明，只需要遵守即可。下面我们来分析下如何遵守这些预定，以及一些常见的范围约定的情况。

注意，如果覆盖了 equals 方法，还要记得覆盖 hashCode 方法。

自反性

对于自反性，我们很难想象 x.equals(x) 在什么情况下会返回 false，但是既然是自己比较自己，那么我们完全可以用操作符 == 来保证这一点

public class Person {
	String name;
	int age;
	
	public Person(String name, int age) {
		this.name = Objects.requireNonNull(name);
		this.age = age;
	}
	
	@Override
	public boolean equals(Object obj) {
		// 通过 == 保证自反性，同时也提升性能
		if (this == obj) {
			return true;
		}
	
		// 暂时省略其他逻辑
		
		return false;
	}
}

对于引用类型，操作符 == 是比较引用值的地址，因此可以很好的确保自反性，并且同时也提升了比较的性能，因为不用再去比较其他的内容。

对称性

对于对称性，如果 x.equals(y) 返回 true，那么 y.equals(x) 也应该返回 true。

一般来说，违背这个约定的有两种情况

  1. 在 equals 方法中把本类的对象与其他类对象进行比较。
  2. 通过继承，在子类中覆盖了超类的 equals 方法。

首先看第一种情况，在 equals 方法中与其他类对象进行比较

public class CaseInsensitiveString {
	private String s;
	
	public CaseInsensitiveString(String s) {
		this.s = Objects.requireNonNull(s);
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		
		if (obj instanceof CaseInsensitiveString) {
			return s.equalsIgnoreCase(((CaseInsensitiveString)obj).s);
		}
		
		// 与String类对象比较，违反对称性
		if (obj instanceof String) {
			return s.equalsIgnoreCase((String)s);
		}
		
		return false;
	}
}

在 equals 方法中，把 CaseInsensitiveString 对象与 String 对象进行比较，并认为可以相等。这会违反对称性，例如

CaseInsensitiveString s = new CaseInsensitiveString("Hello");
String s1 = "Hello";
System.out.println(s.equals(s1)); // true
System.out.println(s1.equals(s)); // false

CaseInsensitiveString 对象与 String 对象比较，返回 true，而 String 对象与 CaseInsensitiveString 对象比较返回 false，因此 CaseInsensitiveString 中的 equals 方法违反了对称性。

从这个例子可以看出，在 equals 方法中，应该只比较本类的对象，而不应该比较其他类的对象。

再来看第二种情况，子类覆盖了超类的 equals 方法。

超类的代码如下

public class Person {
	String name;
	int age;
	
	public Person(String name, int age) {
		this.name = Objects.requireNonNull(name);
		this.age = age;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj instanceof Person) {
			Person p = (Person) obj;
			return name.equals(p.name) && age == p.age;
		}
		
		return false;
	}
}

子类代码如下

public class WeightPerson extends Person{
	private float weight;
	
	public WeightPerson(String name, int age, float weight) {
		super(name, age);
		this.weight = weight;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj) return true;
		
		if (!(obj instanceof WeightPerson)) return false;
		
		WeightPerson wp = (WeightPerson) obj;
		
		return wp.weight == weight && super.equals(obj);
	}

}

WeightPerson 的 equals 方法比较了 weight ，然后通过超类的 equals 方法比较 name 和 age。这段代码看似很完美，但是它违反了对称性

Person p  = new Person("david", 11);
WeightPerson wp = new WeightPerson("david", 11, 60.0f);
System.out.println(p.equals(wp)); // true
System.out.println(wp.equals(p)); // false

从这段测试代码可以发现，超类 Person 对象与子类 WeightPerson 对象，互相比较的结果是不一致的，因此 WeightPerson 的 equals 方法违反了对称性。

其实这是面向对象语言中关于等价关系的一个基本问题: 我们无法在扩展可实例化的类的同时，既增加新的值组件(例如，成员变量), 同时又保留 equals 约定。

为了解决这个问题，有两种方法

  1. 让超类不可实例化，例如超类是一个抽象类。
  2. 选择组合而非继承。

其实，在子类中和超类的 equals 方法中，通过 getClass() 方法来判断类型，可以解决继承所造成的违反对称性的问题，例如

public class Person {
	String name;
	int age;
	
	public Person(String name, int age) {
		this.name = Objects.requireNonNull(name);
		this.age = age;
	}
	
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                name.equals(person.name);
    }
}

<< Effective Java >> 这一书中并不推崇这么做，而是推崇解决继承所造成的问题。

传递性

对于传递性，如果 x.equals(y) 返回 true, 并且 y.equals(z) 返回 true，那么 x.equals(z) 应该返回 true。

通常违反这个约定也是因为继承所造成的，但是只要我们正确的保证了反身性和对称性，传递性就可以保证了。

一致性

对于一致性，如果在 equals 方法中所使用的信息没有改变，那么多次调用 x.equals(y) 返回的结果应该一致。这是什么意思呢?

public class Person {
	String name;
	int age;
	
	public Person(String name, int age) {
		this.name = Objects.requireNonNull(name);
		this.age = age;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj instanceof Person) {
			Person p = (Person) obj;
			return name.equals(p.name) && age == p.age;
		}
		
		return false;
	}
}

Person 的 equals 方法使用了 name 和 age 进行比较，只要我们不修改这两个值，那么多次调用 x.equals(y) ，返回的结果永远是一致的。

因此，不要在 equals 方法中使用一些不可靠资源，例如主机名通过网络可以解析IP地址，但是我们不要比较这个IP地址，因为主机名可能不会变，但是IP地址可能会改变。

非空性

非空性说的是，x.equals(null) 应该返回 false，其实通过 obj instanceof Person 就可以保证非空性。

写好 equals 方法

现在总结下如何写好一个 equals 方法

  1. 通过操作符 == 进行比较，提升性能。
  2. 使用 instanceof 操作符检查类型，保证只与本类对象比较。
  3. 把参数转换为正确的类型。
  4. 对类中关键的信息进行比较。

例如下面的代码，就是一个高质量的 equals 写法

public class Person {
	String name;
	int age;
	
	public Person(String name, int age) {
		this.name = Objects.requireNonNull(name);
		this.age = age;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj instanceof Person) {
			Person p = (Person) obj;
			return Objects.equals(name, p.name) && age == p.age;
		}
		
		return false;
	}
}

但是，请注意，如果使用 instanceof 判断类型，那么注意规避面向对象语言中关于等价关系的一个基本问题: 我们无法在扩展可实例化的类的同时，既增加新的值组件(例如，成员变量), 同时又保留 equals 约定。

如何比较

在 equals 方法中会比较关键信息，但是如何正确的比较，又是一个问题。这也是面试中进场会深究的一个问题。

基本类型比较

对于基本类型的比较，除了 float 和 double 类型外，其他基本类型使用操作符 == 进行比较。

对于 float 和 double 类型，最好分别使用 Float 和 Double 的静态 compare 方法，也就是 Float.compare(float, float) 和 Double.compare(double, double) 进行比较。那么为什么不使用操作符 == 来比较这两个类型的值呢？ 因为有以下两种异常

  1. 对于 float 类型，如果 x, y 的值都为 Float.NaN， x==y 返回的却是 false。 double 类型同样也有这样的问题。
  2. 对于 float 类型，如果 x, y 值为别为 +0.0f 和 -0.0f，x == y 返回 true， 但是如果把 float 对象转换为 Float 对象，然后使用 equals 方法进行比较，返回的却是 false 。double 类型也有同样的问题。

数组的比较

对于基本类型数组，可以使用对应类型 Arrays.equals() 进行比较，例如比较 double 数组，可以使用 Arrays.equals(double[], double[]) 进行比较。当然如果你不嫌麻烦，也可以遍历数组逐个进行比较。

引用类型比较

对于引用类型对象的比较，我们直接使用他们的 equals 方法进行比较，但是有一点需要注意，那就是空指针问题，例如

public class Person {
	String name;
	int age;
	
	public Person(String name, int age) {
		this.name = Objects.requireNonNull(name);
		this.age = age;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj instanceof Person) {
			Person p = (Person) obj;
			return name.equals(p.name) && age == p.age;
		}
		
		return false;
	}
}

name 值可以为 null，因此 name.equals(p.name) 可以会产生空指针异常，我们可以有两种办法来避免这个问题

  1. 在构造函数中通过 Object.requireNonNull() 来保证参数不为空。
  2. 在 equals 方法中，通过 Objects.equals(Object, Object) 进行比较。

比较的性能

在 equals 方法中，如果我们注意一些细节，那么会提升方法的性能

  1. 先比较最有可能不一致的信息。
  2. 先比较开销较低的信息。
  3. 不比较那些可以推导出来的信息。
  4. 不比较一些无关的信息，例如用于同步的 Lock 对象。

写 equals 的科学方法

我们手动写代码会出错，但是机器很难犯错，我们可以利用 IDE 帮我们生成 equals 方法。

例如下面 equals 代码就是 IDE 生成的

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

这个 IDE 生成的 equals 方法，用到了本文所说的各种知识点。

大胃粥
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何书写一个恰当的equals()方法？
吴下阿吉
07-08 1115
若有错误，欢迎指正。 Object类中的equals()方法默认比较的是对象之间的引用是否一样，但在实际开发中需要比较的是对象之间的状态是否一样。这就要求我们覆写equals()方法。 考虑继承层次下的equals()方法应如何书写？ 1、父类的equals()方法比较共有属性部分，等待子类中的equals()调用 2、子类各自覆写equals()方法比较新增属性部分 下面以Person
Java编程中的equals方法使用全解
09-03
主要介绍了Java编程中的equals方法使用全解,是Java入门学习中的基础知识,需要的朋友可以参考下
如何在Java中避免equals方法的隐藏陷阱（上）
12-22
译者注:你可能会觉得Java很简单，Object的equals实现也会非常简单，但是事实并不是你想象的这样，耐心的读完本文，你会发现你对Java了解的是如此的少。如果这篇文章是一份Java程序员的入职笔试，那么不知道有多少人会掉落到这样的陷阱中。 　　摘要 　　本文描述重载equals方法的技术，这种技术即使是具现类的子类增加了字段也能保证equal语义的正确性。 　　在《Effective Java》的第8项中，Josh Bloch描述了当继承类作为面向对象语言中的等价关系的基础问题，要保证派生类的equal正确性语义所会面对的困难。Bloch这样写到： 　　除非你忘记了面向
JAVA——equals方法的写法
NarcissusNumber的博客
06-25 1207
在《java核心技术卷1》中建议equals方法的写法： 1.如果子类拥有自己的相等概念，则使用getclass比较。 public boolean equals (Object otherObject){ if(this == otherObject) //判断是否引用同一个对象 return true; if...
java equals()方法的写法
潇风寒月
07-27 1833
//java equals()方法的写法 @Override public boolean equals(Object o) { if (this == o) { // 如果相等,则返回true return true; } if (o == null) { // 如果指定对象为空 return false; } if (!(o instanceof Perso
Java基础-equals的编写
MyNAMS的博客
09-18 253
编写equals 如何正确编写equals()方法？equals()方法要求我们必须满足以下条件： 自反性（Reflexive）：对于非null的x来说，x.equals(x)必须返回true； 对称性（Symmetric）：对于非null的x和y来说，如果x.equals(y)为true，则y.equals(x)也必须为true； 传递性（Transitive）：对于非null的x、y和z来说，如果x.equals(y)为true，y.equals(z)也为true，那么x.equals(z)也必须为t
java 中的equals()示例代码
我都博客
03-08 1458
public booleanequals(Object obj) 作用：判断其他的对象是否和该对象相等 其比较规则为：当参数obj引用的对象与当前对象为同一个对象时，就返回true,否则返回false.
equals方法详解
热门推荐
qq_57887050的博客
03-19 3万+
一、equale方法是什么？ Object 类中的 equals 方法是用于检测一个对象是否等于另外一个对象。在Object类中实现的 equals 方法将确定两个对象是否具有相同的引用（内存地址）。如果两个对象具有相同的引用，那么他们一定是相等的，看看下面这段代码的运行： public static void main(String[] args) { Object o = new Object(); //分别将 o 赋值给变量o1,o2 Object o1 ...
一文详解java中的==和equals()
文章仅作为参考使用，持续更新中，欢迎批评指导！
08-04 4650
一文详解==运算符和equals()方法
equals()方法总结
bamboo_cqh的博客
12-21 427
equals()           超类Object中有这个equals()方法，该方法主要用于比较两个对象是否相等。该方法的源码如下： public boolean equals(Object obj) { return (this == obj); }       我们知道所有的对象都拥有标识(内存地址)和状态(数据)，同时“==”比较两个对象的的内存地
如何编写完美的 equals 方法
chesian的专栏
06-02 398
1、显示参数命名为otherObject, 稍后需要将它转换成另一个other变量/ 2、检测this 与 otherObject是否为同一引用；       if(this == otherObject)  return true; 3、检测otherObject 是否为null, 如果为null 返回false       if(otherObject == null)
2.javaequals()方法.zip
06-14
2.javaequals()方法.zip2.javaequals()方法.zip2.javaequals()方法.zip2.javaequals()方法.zip2.javaequals()方法.zip2.javaequals()方法.zip2.javaequals()方法.zip2.javaequals()方法.zip2.javaequals()方法.zip2....
Java equals 方法与hashcode 方法的深入解析
09-05
面试时经常会问起字符串比较相关的问题,比如：字符串比较时用的什么方法,内部实现如何?hashcode的作用,以及重写equal方法,为什么要重写hashcode方法?以下就为大家解答，需要的朋友可以参考下
Java中Equals使用方法汇总
08-31
主要采用问答的方式集中讲解了Java中Equals的使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java equals（）方法使用详解及总结
08-31
主要介绍了Java equals（）方法使用详解及总结的相关资料,需要的朋友可以参考下
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 931
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 880
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 279
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Lambda表达式特点
weixin_57763462的博客
04-24 799
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
java重写equals方法
04-10
好的，关于Java重写equals方法，我们可以进行如下解释： 在Java中，equals方法是用来比较两个对象是否相等的。默认情况下，equals方法比较的是两个对象的引用是否相等。如果我们希望比较两个对象的实际值是否相等，就需要重写equals方法，以自定义比较的规则。 在重写equals方法时，我们需要遵循以下原则： 1. 自反性：x.equals(x)应该返回true。 2. 对称性：如果x.equals(y)返回true，则y.equals(x)也应该返回true。 3. 传递性：如果x.equals(y)返回true，并且y.equals(z)返回true，则x.equals(z)也应该返回true。 4. 一致性：如果x.equals(y)返回true，则无论何时调用x.equals(y)的结果都应该保持不变。 5. 非空性：x.equals(null)应该返回false。 重写equals方法时，我们可以考虑比较对象的各个属性是否相同，如果都相同则认为对象相等，否则认为对象不等。需要注意的是，equals方法一定要和hashCode方法一起重写，以保证在使用集合类（如HashMap、HashSet）时能够正常工作。 希望这个回答能够满足您的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值