entityMap|blocks|key|b7evc|text|因为我猜age+++是int类型|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|62j5e|public+boolean+equals(Object+other){
++++boolean+result;
++++if((other+==+null)+%7C%7C+(getClass()+!=+other.getClass())){
++++++++result+=+false;
++++}+//+end+if
++++else{
++++++++People+otherPeople+=+(People)other;
++++++++result+=+name.equals(otherPeople.name)+&&++age+==+otherPeople.age;
++++}+//+end+else

++++return+result;
}+//+end+equals|code-block|syntax|javascript^0|4|6|B|3|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@$A|M|B|N|C|D]|$A|O|B|P|C|D]]|E|@]|F|$]]|$2|G|4|H|6|I|8|Q|9|@]|E|@]|F|$J|K]]]]

Since I'm guessing <code>age</code> is of type <code>int</code>:

<pre><code>public boolean equals(Object other){
 boolean result;
 if((other == null) || (getClass() != other.getClass())){
 result = false;
 } // end if
 else{
 People otherPeople = (People)other;
 result = name.equals(otherPeople.name) &amp;&amp; age == otherPeople.age;
 } // end else

 return result;
} // end equals
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://stackoverflow.com/questions/27581/overriding-equals-and-hashcode-in-java|blocks|key|brg5j|text|我不确定细节，因为你还没有发布完整的代码，但是：|unstyled|depth|inlineStyleRanges|entityRanges|cnfg4|记住覆盖还有hashCode()|offset|length|style|CODE|92o32|the+equals方法应具有Object，notPeople|fd756|作为其参数类型。目前您正在重载equals方法，而不是重写equals方法，这可能不是您想要的，特别是考虑到您稍后会检查它的类型。|f0i0b|您可以使用instanceof要检查它是一个人物对象，例如if+(!(other+instanceof+People))+{+result+=+false;}|1amdh|equals用于所有对象，但不是基元。我想你的意思是年龄是一个int(原语)，在这种情况下只需使用==。请注意，Integer+(带有大写'I')是一个对象，应该与equals进行比较。|378g7|请参见What+issues+should+be+considered+when+overriding+equals+and+hashCode+in+Java?了解更多详细信息。^0|0|6|A|0|4|6|F|6|P|6|0|0|5|A|T|1E|0|0|6|V|3|1D|2|0|3|25|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|Y|G|@]|H|@]|6|$]]|$A|I|C|J|2|E|F|Z|G|@$K|10|L|11|M|N]]|H|@]|6|$]]|$A|O|C|P|2|E|F|12|G|@$K|13|L|14|M|N]|$K|15|L|16|M|N]|$K|17|L|18|M|N]]|H|@]|6|$]]|$A|Q|C|R|2|E|F|19|G|@]|H|@]|6|$]]|$A|S|C|T|2|E|F|1A|G|@$K|1B|L|1C|M|N]|$K|1D|L|1E|M|N]]|H|@]|6|$]]|$A|U|C|V|2|E|F|1F|G|@$K|1G|L|1H|M|N]|$K|1I|L|1J|M|N]|$K|1K|L|1L|M|N]]|H|@]|6|$]]|$A|W|C|X|2|E|F|1M|G|@]|H|@$K|1N|L|1O|A|1P]]|6|$]]]]

I'm not sure of the details as you haven't posted the whole code, but:

<ul>
<li>remember to override <code>hashCode()</code> as well</li>
<li>the <code>equals</code> method should have <code>Object</code>, not <code>People</code> as its argument type. At the moment you are overloading, not overriding, the equals method, which probably isn't what you want, especially given that you check its type later.</li>
<li>you can use <code>instanceof</code> to check it is a People object e.g. <code>if (!(other instanceof People)) { result = false;}</code></li>
<li><code>equals</code> is used for all objects, but not primitives. I think you mean age is an <code>int</code> (primitive), in which case just use <code>==</code>. Note that an Integer (with a capital 'I') is an Object which should be compared with equals.</li>
</ul>

See <a href="https://stackoverflow.com/questions/27581/overriding-equals-and-hashcode-in-java">What issues should be considered when overriding equals and hashCode in Java?</a> for more details.

entityMap|blocks|key|34h3e|text|如果age是整型的，你应该使用==，如果它是整型对象，那么你可以使用equals()。如果覆盖equals，还需要实现hashcode方法。合同的细节可以在Object的javadoc中获得，也可以在web的各个页面上找到。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

if age is int you should use == if it is Integer object then you can use equals().
You also need to implement hashcode method if you override equals. Details of the contract is available in the javadoc of Object and also at various pages in web.

entityMap|blocks|key|82cl7|text|引入更改参数类型的新方法签名称为重载|type|unstyled|depth|inlineStyleRanges|entityRanges|data|d7c2j|public+boolean+equals(People+other){|code-block|syntax|javascript|91c8p|这里People不同于Object。|offset|length|style|CODE|6q9ad|当方法签名与其超类的签名保持相同时，将调用该方法签名覆盖和@Override|52dju|注释有助于在编译时区分这两者：|ajisn|@Override
public+boolean+equals(Object+other){|9f72i|在没有看到实际声明的情况下age，很难说为什么会出现这个错误。^0|0|0|2|6|B|6|0|T|9|0|0|0|D|3^^$0|$]|1|@$2|3|4|5|6|7|8|V|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|W|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|X|9|@$J|Y|K|Z|L|M]|$J|10|K|11|L|M]]|A|@]|B|$]]|$2|N|4|O|6|7|8|12|9|@$J|13|K|14|L|M]]|A|@]|B|$]]|$2|P|4|Q|6|7|8|15|9|@]|A|@]|B|$]]|$2|R|4|S|6|E|8|16|9|@]|A|@]|B|$F|G]]|$2|T|4|U|6|7|8|17|9|@$J|18|K|19|L|M]]|A|@]|B|$]]]]

Introducing a new method signature that changes the parameter types is called overloading:

<pre class="lang-java prettyprint-override"><code>public boolean equals(People other){
</code></pre>

Here <code>People</code> is different than <code>Object</code>.

When a method signature remains the identical to that of its superclass, it is called overriding and the <code>@Override</code> annotation helps distinguish the two at compile-time:

<pre class="lang-java prettyprint-override"><code>@Override
public boolean equals(Object other){
</code></pre>

Without seeing the actual declaration of <code>age</code>, it is difficult to say why the error appears.

entityMap|blocks|key|9i40n|text|//Written+by+K@stackoverflow
public+class+Main+{

++++/**
+++++*+@param+args+the+command+line+arguments
+++++*/
++++public+static+void+main(String[]+args)+{
++++++++//+TODO+code+application+logic+here
++++++++ArrayList+people+=+new+ArrayList();
++++++++people.add(new+Person("Subash+Adhikari",+28));
++++++++people.add(new+Person("K",+28));
++++++++people.add(new+Person("StackOverflow",+4));
++++++++people.add(new+Person("Subash+Adhikari",+28));

++++++++for+(int+i+=+0;+i+<+people.size()+-+1;+i%2B%2B)+{
++++++++++++for+(int+y+=+i+%2B+1;+y+<=+people.size()+-+1;+y%2B%2B)+{
++++++++++++++++boolean+check+=+people.get(i).equals(people.get(y));

++++++++++++++++System.out.println("--+"+%2B+people.get(i).getName()+%2B+"+-+VS+-+"+%2B+people.get(y).getName());
++++++++++++++++System.out.println(check);
++++++++++++}
++++++++}
++++}
}

//written+by+K@stackoverflow
public+class+Person+{
++++private+String+name;
++++private+int+age;

++++public+Person(String+name,+int+age){
++++++++this.name+=+name;
++++++++this.age+=+age;
++++}

++++@Override
++++public+boolean+equals(Object+obj)+{
++++++++if+(obj+==+null)+{
++++++++++++return+false;
++++++++}

++++++++if+(obj.getClass()+!=+this.getClass())+{
++++++++++++return+false;
++++++++}

++++++++final+Person+other+=+(Person)+obj;
++++++++if+((this.name+==+null)+?+(other.name+!=+null)+:+!this.name.equals(other.name))+{
++++++++++++return+false;
++++++++}

++++++++if+(this.age+!=+other.age)+{
++++++++++++return+false;
++++++++}

++++++++return+true;
++++}

++++@Override
++++public+int+hashCode()+{
++++++++int+hash+=+3;
++++++++hash+=+53+*+hash+%2B+(this.name+!=+null+?+this.name.hashCode()+:+0);
++++++++hash+=+53+*+hash+%2B+this.age;
++++++++return+hash;
++++}

++++public+int+getAge()+{
++++++++return+age;
++++}

++++public+void+setAge(int+age)+{
++++++++this.age+=+age;
++++}

++++public+String+getName()+{
++++++++return+name;
++++}

++++public+void+setName(String+name)+{
++++++++this.name+=+name;
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5k6po|输出：|unstyled|aefj1|运行：|bpcgm|--+Subash+Adhikari+-+VS+-K+false|e898v|--+Subash+Adhikari+-+VS+-+StackOverflow+false|62i98|--+Subash+Adhikari+-+VS+-+Subash+Adhikari+true|fh6q6|--+K-+VS+-+StackOverflow+false|c0ta8|--+K-+VS+-+Subash+Adhikari+false|4909r|--+StackOverflow+-+VS+-+Subash+Adhikari+false|8oqbp|--构建成功(总时间:0秒)^0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|X|9|@]|A|@]|B|$C|D]]|$2|E|4|F|6|G|8|Y|9|@]|A|@]|B|$]]|$2|H|4|I|6|G|8|Z|9|@]|A|@]|B|$]]|$2|J|4|K|6|G|8|10|9|@]|A|@]|B|$]]|$2|L|4|M|6|G|8|11|9|@]|A|@]|B|$]]|$2|N|4|O|6|G|8|12|9|@]|A|@]|B|$]]|$2|P|4|Q|6|G|8|13|9|@]|A|@]|B|$]]|$2|R|4|S|6|G|8|14|9|@]|A|@]|B|$]]|$2|T|4|U|6|G|8|15|9|@]|A|@]|B|$]]|$2|V|4|W|6|G|8|16|9|@]|A|@]|B|$]]]]

<pre><code>//Written by K@stackoverflow
public class Main {

 /**
 * @param args the command line arguments
 */
 public static void main(String[] args) {
 // TODO code application logic here
 ArrayList&lt;Person&gt; people = new ArrayList&lt;Person&gt;();
 people.add(new Person(&quot;Subash Adhikari&quot;, 28));
 people.add(new Person(&quot;K&quot;, 28));
 people.add(new Person(&quot;StackOverflow&quot;, 4));
 people.add(new Person(&quot;Subash Adhikari&quot;, 28));

 for (int i = 0; i &lt; people.size() - 1; i++) {
 for (int y = i + 1; y &lt;= people.size() - 1; y++) {
 boolean check = people.get(i).equals(people.get(y));

 System.out.println(&quot;-- &quot; + people.get(i).getName() + &quot; - VS - &quot; + people.get(y).getName());
 System.out.println(check);
 }
 }
 }
}

//written by K@stackoverflow
public class Person {
 private String name;
 private int age;

 public Person(String name, int age){
 this.name = name;
 this.age = age;
 }

 @Override
 public boolean equals(Object obj) {
 if (obj == null) {
 return false;
 }

 if (obj.getClass() != this.getClass()) {
 return false;
 }

 final Person other = (Person) obj;
 if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
 return false;
 }

 if (this.age != other.age) {
 return false;
 }

 return true;
 }

 @Override
 public int hashCode() {
 int hash = 3;
 hash = 53 * hash + (this.name != null ? this.name.hashCode() : 0);
 hash = 53 * hash + this.age;
 return hash;
 }

 public int getAge() {
 return age;
 }

 public void setAge(int age) {
 this.age = age;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }
}
</code></pre>
Output:
<blockquote>
run:
-- Subash Adhikari - VS - K false
-- Subash Adhikari - VS - StackOverflow false
-- Subash Adhikari - VS - Subash Adhikari true
-- K - VS - StackOverflow false
-- K - VS - Subash Adhikari false
-- StackOverflow - VS - Subash Adhikari false
-- BUILD SUCCESSFUL (total time: 0 seconds)
</blockquote>

entityMap|blocks|key|c1ff0|text|@Override
public+boolean+equals(Object+that){
++if(this+==+that)+return+true;//if+both+of+them+points+the+same+address+in+memory

++if(!(that+instanceof+People))+return+false;+//+if+"that"+is+not+a+People+or+a+childclass

++People+thatPeople+=+(People)that;+//+than+we+can+cast+it+to+People+safely

++return+this.name.equals(thatPeople.name)+&&+this.age+==+thatPeople.age;//+if+they+have+the+same+name+and+same+age,+then+the+2+objects+are+equal+unless+they're+pointing+to+different+memory+adresses
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript^0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$C|D]]]]

<pre><code>@Override
public boolean equals(Object that){
 if(this == that) return true;//if both of them points the same address in memory

 if(!(that instanceof People)) return false; // if "that" is not a People or a childclass

 People thatPeople = (People)that; // than we can cast it to People safely

 return this.name.equals(thatPeople.name) &amp;&amp; this.age == thatPeople.age;// if they have the same name and same age, then the 2 objects are equal unless they're pointing to different memory adresses
}
</code></pre>

entityMap|blocks|key|3c5dc|text|在比较Java中的对象时，您需要创建一个语义检查，比较类型和标识状态|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4pq85|要执行以下操作的对象的数量：|b3558|自身(相同实例)|dqj5a|自身(克隆或重建拷贝)|292rg|其他不同类型的对象|c7iq|相同类型的其他对象|30hho|null|offset|length|style|CODE|5226f|规则：|d3oaq|对称性：a.equals(b)+==+b.equals(a)equals()总是让步true或者false，但从来不是NullpointerException，ClassCastException|ad6t7|或任何其他可抛出的|c9vug|比较：|9ofb8|类型检查：两个实例都需要是相同类型，这意味着您必须比较实际的类是否相等。当开发人员使用instanceof用于类型比较(仅当没有子类时才起作用，并且在以下情况下违反对称规则。A+extends+B+->+a+instanceof+b+!=+b+instanceof+a)|1ttn|标识状态的语义检查：确保您了解实例是通过哪种状态标识的。人们可以通过他们的社会安全号码来识别，但不能通过发色(可以染色)、姓名(可以改变)或年龄(一直在改变)来识别。只有值对象才应该比较完整的状态(所有非瞬态字段)，否则只检查标识实例的内容。|daj0f|为您的Person类：|57blf|public+boolean+equals(Object+obj)+{

++++//+same+instance
++++if+(obj+==+this)+{
++++++++return+true;
++++}
++++//+null
++++if+(obj+==+null)+{
++++++++return+false;
++++}
++++//+type
++++if+(!getClass().equals(obj.getClass()))+{
++++++++return+false;
++++}
++++//+cast+and+compare+state
++++Person+other+=+(Person)+obj;
++++return+Objects.equals(name,+other.name)+&&+Objects.equals(age,+other.age);
}|code-block|syntax|javascript|d0njp|可重用的通用工具类：|aordv|public+final+class+Equals+{

++++private+Equals()+{
++++++++//+private+constructor,+no+instances+allowed
++++}

++++/**
+++++*+Convenience+equals+implementation,+does+the+object+equality,+null+and+type+checking,+and+comparison+of+the+identifying+state
+++++*
+++++*+@param+instance+++++++object+instance+(where+the+equals()+is+implemented)
+++++*+@param+other++++++++++other+instance+to+compare+to
+++++*+@param+stateAccessors+stateAccessors+for+state+to+compare,+optional
+++++*+@param+++++++++++++instance+type
+++++*+@return+true+when+equals,+false+otherwise
+++++*/
++++public+static++boolean+as(T+instance,+Object+other,+Function...+stateAccessors)+{
++++++++if+(instance+==+null)+{
++++++++++++return+other+==+null;
++++++++}
++++++++if+(instance+==+other)+{
++++++++++++return+true;
++++++++}
++++++++if+(other+==+null)+{
++++++++++++return+false;
++++++++}
++++++++if+(!instance.getClass().equals(other.getClass()))+{
++++++++++++return+false;
++++++++}
++++++++if+(stateAccessors+==+null)+{
++++++++++++return+true;
++++++++}
++++++++return+Stream.of(stateAccessors).allMatch(s+->+Objects.equals(s.apply(instance),+s.apply((T)+other)));
++++}
}|fk1cj|为您的Person类，使用这个实用程序类：|d5t43|public+boolean+equals(Object+obj)+{
++++return+Equals.as(this,+obj,+t+->+t.name,+t+->+t.age);
}^0|0|0|0|0|0|0|0|4|0|0|4|Y|16|4|1C|5|1N|K|28|I|0|0|0|17|A|2F|1C|0|0|3|6|0|0|0|0|3|6|0^^$0|$]|1|@$2|3|4|5|6|7|8|1J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|1K|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|1L|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|1M|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|1N|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|1O|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|1P|9|@$O|1Q|P|1R|Q|R]]|A|@]|B|$]]|$2|S|4|T|6|7|8|1S|9|@]|A|@]|B|$]]|$2|U|4|V|6|7|8|1T|9|@$O|1U|P|1V|Q|R]|$O|1W|P|1X|Q|R]|$O|1Y|P|1Z|Q|R]|$O|20|P|21|Q|R]|$O|22|P|23|Q|R]]|A|@]|B|$]]|$2|W|4|X|6|7|8|24|9|@]|A|@]|B|$]]|$2|Y|4|Z|6|7|8|25|9|@]|A|@]|B|$]]|$2|10|4|11|6|7|8|26|9|@$O|27|P|28|Q|R]|$O|29|P|2A|Q|R]]|A|@]|B|$]]|$2|12|4|13|6|7|8|2B|9|@]|A|@]|B|$]]|$2|14|4|15|6|7|8|2C|9|@$O|2D|P|2E|Q|R]]|A|@]|B|$]]|$2|16|4|17|6|18|8|2F|9|@]|A|@]|B|$19|1A]]|$2|1B|4|1C|6|7|8|2G|9|@]|A|@]|B|$]]|$2|1D|4|1E|6|18|8|2H|9|@]|A|@]|B|$19|1A]]|$2|1F|4|1G|6|7|8|2I|9|@$O|2J|P|2K|Q|R]]|A|@]|B|$]]|$2|1H|4|1I|6|18|8|2L|9|@]|A|@]|B|$19|1A]]]]

When comparing objects in Java, you make a semantic check, comparing the type and identifying state of the objects to:

<ul>
<li>itself (same instance)</li>
<li>itself (clone, or reconstructed copy)</li>
<li>other objects of different types</li>
<li>other objects of the same type</li>
<li><code>null</code></li>
</ul>

Rules:

<ul>
<li>Symmetry: <code>a.equals(b) == b.equals(a)</code></li>
<li><code>equals()</code> always yields <code>true</code> or <code>false</code>, but never a <code>NullpointerException</code>, <code>ClassCastException</code> or any other throwable</li>
</ul>

Comparison:

<ul>
<li>Type check: both instances need to be of the same type, meaning you have to compare the actual classes for equality. This is often not correctly implemented, when developers use <code>instanceof</code> for type comparison (which only works as long as there are no subclasses, and violates the symmetry rule when <code>A extends B -&gt; a instanceof b != b instanceof a)</code>. </li>
<li>Semantic check of identifying state: Make sure you understand by which state the instances are identified. Persons may be identified by their social security number, but not by hair color (can be dyed), name (can be changed) or age (changes all the time). Only with value objects should you compare the full state (all non-transient fields), otherwise check only what identifies the instance. </li>
</ul>

For your <code>Person</code> class:

<pre><code>public boolean equals(Object obj) {

 // same instance
 if (obj == this) {
 return true;
 }
 // null
 if (obj == null) {
 return false;
 }
 // type
 if (!getClass().equals(obj.getClass())) {
 return false;
 }
 // cast and compare state
 Person other = (Person) obj;
 return Objects.equals(name, other.name) &amp;&amp; Objects.equals(age, other.age);
}
</code></pre>

Reusable, generic utility class:

<pre><code>public final class Equals {

 private Equals() {
 // private constructor, no instances allowed
 }

 /**
 * Convenience equals implementation, does the object equality, null and type checking, and comparison of the identifying state
 *
 * @param instance object instance (where the equals() is implemented)
 * @param other other instance to compare to
 * @param stateAccessors stateAccessors for state to compare, optional
 * @param &lt;T&gt; instance type
 * @return true when equals, false otherwise
 */
 public static &lt;T&gt; boolean as(T instance, Object other, Function&lt;? super T, Object&gt;... stateAccessors) {
 if (instance == null) {
 return other == null;
 }
 if (instance == other) {
 return true;
 }
 if (other == null) {
 return false;
 }
 if (!instance.getClass().equals(other.getClass())) {
 return false;
 }
 if (stateAccessors == null) {
 return true;
 }
 return Stream.of(stateAccessors).allMatch(s -&gt; Objects.equals(s.apply(instance), s.apply((T) other)));
 }
}
</code></pre>

For your <code>Person</code> class, using this utility class:

<pre><code>public boolean equals(Object obj) {
 return Equals.as(this, obj, t -&gt; t.name, t -&gt; t.age);
}
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://rads.stackoverflow.com/amzn/click/com/0134685997|blocks|key|9p262|text|第十项:当覆盖等于时，遵守总合同|unstyled|depth|inlineStyleRanges|entityRanges|1cljd|According+to+Effective+Java,，重写equals方法看起来很简单，但有很多方法会出错，后果可能会很严重。避免问题的最简单方法是不要重写equals方法，在这种情况下，类的每个实例仅与其自身相等。如果满足以下任一条件，则这是正确的做法：|offset|length|style|CODE|aiu4|c8nid|类的每个实例在本质上都是唯一的。对于像Thread这样表示活动实体而不是值的类来说，这是正确的。Object提供的equals实现为这些类提供了正确的行为。|883f2|类不需要提供“逻辑相等”测试。例如，java.util.regex.Pattern可以重写equals来检查两个模式实例是否表示完全相同的正则表达式，但是设计者认为客户不需要或不想要这个功能。在这些情况下，从Object继承的equals实现是理想的。|5prc0|超类已经重写了equals，超类行为适用于这个类。例如，大多数Set实现从AbstractSet继承了它们的equals实现，从AbstractList继承了List实现，从AbstractMap继承了Map实现。|fcq3s|类是私有的或包私有的，并且您可以确定它的equals方法永远不会被调用。如果您非常厌恶风险，您可以覆盖equals方法，以确保它不会被意外调用：|2deo2|equals+方法实现了一个等价关系。它具有以下属性：自反：对于任何非空引用值+x，x.equals(x)+必须返回+true。对称：对于任何非空引用值+x+和+y，当且仅当+y.equals(x)+返回+true+时，x.equals(y)+必须返回+true。传递性：对于任何非空引用值+x、y、z，如果+x.equals(y)+返回+true+并且+y.equals(z)+返回+true，则+x.equals(z)+必须返回+true。一致：对于任何非空引用值+x+和+y，x.equals(y)+的多次调用必须始终返回+true+或始终返回+false，前提是不修改+equals+比较中使用的信息。对于任何非空引用值+x，x.equals(null)+必须返回+false。|cd8qp|cgloq|下面是一个高质量的equals方法的秘诀：使用==运算符检查参数是否为对此对象的引用。如果是，则返回true。这只是一个性能优化，但如果比较可能很昂贵，那么这是值得做的。|f7s1r|使用instanceof|f47ns|运算符检查参数的类型是否正确。如果不是，则返回false。通常，正确的类型是出现该方法的类。有时，它是这个类实现的某个接口。如果类实现了一个接口，该接口改进了equals协定以允许在实现该接口的类之间进行比较，则使用该接口。集合接口具有此属性。|ceqi6|将参数转换为正确的类型。由于此强制转换之前有一个instanceof测试，因此它肯定会成功。|1d70j|对于类中的每个“重要”字段，检查该参数的字段是否与该对象的相应字段匹配。如果所有这些测试都成功，则返回true；否则，返回false。如果步骤2中的类型是接口，则必须通过接口方法访问参数的字段；如果类型是类，则可以直接访问字段，具体取决于字段的可访问性。|f3fv3|对于类型不是的基元字段float或者double，请使用==运算符进行比较；对于对象引用字段，请调用equals|1j93a|方法；forfloat|dv9q|字段，请使用静态Float.compare(float,+float)|7d88s|方法；以及double|5rp62|字段，使用Double.compare(double,+double)。字段的存在使得对浮点型和双精度型字段的特殊处理成为必要。F-0.0float,+-0.0f和类似的双精度值；而你可以比较float和double字段使用静态方法Float.equals和Double.equals，这将需要在每次比较时自动装箱，这将具有较差的性能。对于array字段，请将这些准则应用于每个元素。如果数组字段中的每个元素都是重要的，则使用方法Arrays.equals。某些对象引用字段可能合法地包含null|deppq|。要避免出现以下情况的可能性，请执行以下操作：NullPointerException，使用静态方法检查这些字段是否相等。Objects.equals(Object,+Object)。|eo0jq|//具有典型的equals方法的类public+final类PhoneNumber+{+private+final+short+areaCode，prefix，lineNum；public+PhoneNumber(int+areaCode，int+prefix，int+lineNum)+{+this.areaCode+=+rangeCheck(areaCode，999，“地区码”)；this.prefix+=+rangeCheck(prefix，999，"prefix")；this.lineNum+=+rangeCheck(lineNum，9999，"line+num")；}+private+static+short+rangeCheck(int+val，int+max，String+arg)+{+if+(val+<0+%7C%7C+val+>+max)抛出新的IllegalArgumentException(arg+%2B+"：“%2B+val)；return+(short)+val；}+@Override+public+boolean+equals(Object+o)+{+if+(o+==+this)+return+true；if+(!(o+instanceof+PhoneNumber))+return+false；PhoneNumber+pn+=+(PhoneNumber)o；return+pn.lineNum+==+lineNum+&&+pn.prefix+==+prefix+&&+pn.areaCode+==+areaCode；}+...+//省略剩余部分}^0|0|V|6|28|6|0|R|0|0|0|0|0|0|0|0|7|13|2|16|1|18|9|25|1|28|2|32|B|42|1|44|1|46|1|4B|B|4Q|4|4X|C|5D|4|5K|C|60|5|6J|1|6M|2|6P|B|7D|4|7O|5|81|6|8R|1|8T|E|9D|5|0|0|N|2|0|2|A|0|0|0|0|B|5|I|6|S|2|1E|6|0|6|5|0|8|R|0|5|6|0|5|U|1S|A|24|5|2O|5|2U|6|38|C|3L|D|4Q|5|5Z|D|6S|4|0|N|K|1P|U|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|1O|G|@]|H|@]|6|$]]|$A|I|C|J|2|E|F|1P|G|@$K|1Q|L|1R|M|N]|$K|1S|L|1T|M|N]]|H|@$K|1U|L|1V|A|1W]]|6|$]]|$A|O|C|-4|2|E|F|1X|G|@]|H|@]|6|$]]|$A|P|C|Q|2|E|F|1Y|G|@]|H|@]|6|$]]|$A|R|C|S|2|E|F|1Z|G|@]|H|@]|6|$]]|$A|T|C|U|2|E|F|20|G|@]|H|@]|6|$]]|$A|V|C|W|2|E|F|21|G|@]|H|@]|6|$]]|$A|X|C|Y|2|E|F|22|G|@$K|23|L|24|M|N]|$K|25|L|26|M|N]|$K|27|L|28|M|N]|$K|29|L|2A|M|N]|$K|2B|L|2C|M|N]|$K|2D|L|2E|M|N]|$K|2F|L|2G|M|N]|$K|2H|L|2I|M|N]|$K|2J|L|2K|M|N]|$K|2L|L|2M|M|N]|$K|2N|L|2O|M|N]|$K|2P|L|2Q|M|N]|$K|2R|L|2S|M|N]|$K|2T|L|2U|M|N]|$K|2V|L|2W|M|N]|$K|2X|L|2Y|M|N]|$K|2Z|L|30|M|N]|$K|31|L|32|M|N]|$K|33|L|34|M|N]|$K|35|L|36|M|N]|$K|37|L|38|M|N]|$K|39|L|3A|M|N]|$K|3B|L|3C|M|N]|$K|3D|L|3E|M|N]|$K|3F|L|3G|M|N]]|H|@]|6|$]]|$A|Z|C|-4|2|E|F|3H|G|@]|H|@]|6|$]]|$A|10|C|11|2|E|F|3I|G|@$K|3J|L|3K|M|N]]|H|@]|6|$]]|$A|12|C|13|2|E|F|3L|G|@$K|3M|L|3N|M|N]]|H|@]|6|$]]|$A|14|C|15|2|E|F|3O|G|@]|H|@]|6|$]]|$A|16|C|17|2|E|F|3P|G|@]|H|@]|6|$]]|$A|18|C|19|2|E|F|3Q|G|@]|H|@]|6|$]]|$A|1A|C|1B|2|E|F|3R|G|@$K|3S|L|3T|M|N]|$K|3U|L|3V|M|N]|$K|3W|L|3X|M|N]|$K|3Y|L|3Z|M|N]]|H|@]|6|$]]|$A|1C|C|1D|2|E|F|40|G|@$K|41|L|42|M|N]]|H|@]|6|$]]|$A|1E|C|1F|2|E|F|43|G|@$K|44|L|45|M|N]]|H|@]|6|$]]|$A|1G|C|1H|2|E|F|46|G|@$K|47|L|48|M|N]]|H|@]|6|$]]|$A|1I|C|1J|2|E|F|49|G|@$K|4A|L|4B|M|N]|$K|4C|L|4D|M|N]|$K|4E|L|4F|M|N]|$K|4G|L|4H|M|N]|$K|4I|L|4J|M|N]|$K|4K|L|4L|M|N]|$K|4M|L|4N|M|N]|$K|4O|L|4P|M|N]|$K|4Q|L|4R|M|N]|$K|4S|L|4T|M|N]]|H|@]|6|$]]|$A|1K|C|1L|2|E|F|4U|G|@$K|4V|L|4W|M|N]|$K|4X|L|4Y|M|N]]|H|@]|6|$]]|$A|1M|C|1N|2|E|F|4Z|G|@]|H|@]|6|$]]]]

<h3>Item 10: Obey the general contract when overriding equals</h3>

<blockquote>
 <a href="https://rads.stackoverflow.com/amzn/click/com/0134685997" rel="noreferrer" rel="nofollow noreferrer">According to Effective Java</a>, Overriding the <code>equals</code> method seems simple, but there are many ways to get it wrong, and consequences can be dire. The easiest way to avoid problems is not to override the <code>equals</code> method, in which case each instance of the class is equal only to itself. This is the right thing to do if any of the following conditions apply:
</blockquote>

<ul>
<li>Each instance of the class is inherently unique. This is true for classes such as Thread that represent active entities rather than values. The equals implementation provided by Object has exactly the right behavior for these classes.</li>
<li>There is no need for the class to provide a “logical equality” test. For example, java.util.regex.Pattern could have overridden equals to check whether two Pattern instances represented exactly the same regular expression, but the designers didn’t think that clients would need or want this functionality. Under these circumstances, the equals implementation inherited from Object is ideal.</li>
<li>A superclass has already overridden equals, and the superclass behavior is appropriate for this class. For example, most Set implementations inherit their equals implementation from AbstractSet, List implementations from AbstractList, and Map implementations from AbstractMap.</li>
<li>The class is private or package-private, and you are certain that its equals method will never be invoked. If you are extremely risk-averse, you can override the equals method to ensure that it isn’t invoked accidentally:</li>
</ul>

<h3>The <code>equals</code> method implements an equivalence relation. It has these properties:</h3>

<ul>
<li>Reflexive: For any non-null reference value <code>x</code>, <code>x.equals(x)</code> must return true.</li>
<li>Symmetric: For any non-null reference values <code>x</code> and <code>y</code>, <code>x.equals(y)</code> must return true if and only if y.equals(x) returns true.</li>
<li>Transitive: For any non-null reference values <code>x</code>, <code>y</code>, <code>z</code>, if <code>x.equals(y)</code> returns <code>true</code> and <code>y.equals(z)</code> returns <code>true</code>, then <code>x.equals(z)</code> must return <code>true</code>.</li>
<li>Consistent: For any non-null reference values <code>x</code> and <code>y</code>, multiple invocations of <code>x.equals(y)</code> must consistently return <code>true</code> or consistently return <code>false</code>, provided no information used in equals comparisons is modified.</li>
<li>For any non-null reference value <code>x</code>, <code>x.equals(null)</code> must return <code>false</code>.</li>
</ul>

<h3>Here’s a recipe for a high-quality equals method:</h3>

<ol>
<li>Use the <code>==</code> operator to check if the argument is a reference to this object. If so, return true. This is just a performance optimization but one that is worth doing if the comparison is potentially expensive.</li>
<li>Use the <code>instanceof</code> operator to check if the argument has the correct type. If not, return false. Typically, the correct type is the class in which the method occurs. Occasionally, it is some interface implemented by this class. Use an interface if the class implements an interface that refines the equals contract to permit comparisons across classes that implement the interface. Collection interfaces such as Set, List, Map, and Map.Entry have this property.</li>
<li>Cast the argument to the correct type. Because this cast was preceded by an instanceof test, it is guaranteed to succeed.</li>
<li>For each “significant” field in the class, check if that field of the argument matches the corresponding field of this object. If all these tests succeed, return true; otherwise, return false. If the type in Step 2 is an interface, you must access the argument’s fields via interface methods; if the type is a class, you may be able to access the fields directly, depending on their accessibility.</li>
<li>For primitive fields whose type is not <code>float</code> or <code>double</code>, use the <code>==</code> operator for comparisons; for object reference fields, call the <code>equals</code> method recursively; for <code>float</code> fields, use the static <code>Float.compare(float, float)</code> method; and for <code>double</code> fields, use <code>Double.compare(double, double)</code>. The special treatment of float and double fields is made necessary by the existence of <code>Float.NaN</code>, <code>-0.0f</code> and the analogous double values; While you could compare <code>float</code> and <code>double</code> fields with the static methods <code>Float.equals</code> and <code>Double.equals</code>, this would entail autoboxing on every comparison, which would have poor performance. For <code>array</code> fields, apply these guidelines to each element. If every element in an array field is significant, use one of the <code>Arrays.equals</code> methods.</li>
<li>Some object reference fields may legitimately contain <code>null</code>. To avoid the possibility of a <code>NullPointerException</code>, check such fields for equality using the static method <code>Objects.equals(Object, Object)</code>.

<pre><code>// Class with a typical equals method

public final class PhoneNumber {

 private final short areaCode, prefix, lineNum;

 public PhoneNumber(int areaCode, int prefix, int lineNum) {

 this.areaCode = rangeCheck(areaCode, 999, "area code");

 this.prefix = rangeCheck(prefix, 999, "prefix");

 this.lineNum = rangeCheck(lineNum, 9999, "line num");

 }

 private static short rangeCheck(int val, int max, String arg) {

 if (val &lt; 0 || val &gt; max)

 throw new IllegalArgumentException(arg + ": " + val);

 return (short) val;

 }

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

}
</code></pre></li>
</ol>

entityMap|blocks|key|agt7f|text|以下是我最近使用的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|6l3eo|public+class+Test+{
++++public+String+a;
++++public+long+b;
++++public+Date+c;
++++public+String+d;
++++
++++@Override
++++public+boolean+equals(Object+obj)+{
++++++++if+(this+==+obj)+{
++++++++++++return+true;
++++++++}
++++++++if+(!(obj+instanceof+Test))+{
++++++++++++return+false;
++++++++}
++++++++Test+testOther+=+(Test)+obj;
++++++++return+(a+!=+null+?+a.equals(testOther.a)+:+testOther.a+==+null)
++++++++++++++++&&+(b+==+testOther.b)
++++++++++++++++&&+(c+!=+null+?+c.equals(testOther.c)+:+testOther.c+==+null)
++++++++++++++++&&+(d+!=+null+?+d.equals(testOther.d)+:+testOther.d+==+null);
++++}

}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Here is the solution that I recently used:
<pre><code>public class Test {
 public String a;
 public long b;
 public Date c;
 public String d;
 
 @Override
 public boolean equals(Object obj) {
 if (this == obj) {
 return true;
 }
 if (!(obj instanceof Test)) {
 return false;
 }
 Test testOther = (Test) obj;
 return (a != null ? a.equals(testOther.a) : testOther.a == null)
 &amp;&amp; (b == testOther.b)
 &amp;&amp; (c != null ? c.equals(testOther.c) : testOther.c == null)
 &amp;&amp; (d != null ? d.equals(testOther.d) : testOther.d == null);
 }

}
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://en.wikipedia.org/wiki/Java_version_history#Java_SE_16|1|https://openjdk.java.net/jeps/395|blocks|key|b71cd|text|tl;dr|unstyled|depth|inlineStyleRanges|entityRanges|69nv|record+Person+(+String+name+,+int+age+)+{}++
if(+
++++new+Person(+"Carol"+,+27+)++++++++++++++//+Compiler+auto-generates+implicitly+the+constructor.
++++.equals(++++++++++++++++++++++++++++++++//+Compiler+auto-generates+implicitly+the+`equals`+method.
++++++++new+Person(+"Carol"+,+42+)+
++++)+
)+++++++++++++++++++++++++++++++++++++++++++//+Returns+`false`,+as+the+name+matches+but+the+age+differs.
{+…+}|code-block|syntax|javascript|8gemk|详细信息|fo157|当您的特定问题得到解决时(使用==进行相等性测试int原始值)，有一种替代方法可以消除编写该代码的需要。|offset|length|style|CODE|cpbs8|record|header-one|BOLD|3n4iq|Java+16带来了record功能。|472lt|记录是编写类的一种简单方法，该类的主要目的是透明且不变地携带数据。编译器隐式地创建构造函数、gettersequals&hashCode，以及toString。|bougb|equals自动提供的方法|97shg|默认的隐式equals方法比较您为记录声明的每个成员字段。成员可以是对象或基元，默认情况下会自动比较这两种类型equals方法。|5hbfq|例如，如果您有一个Person包含两个字段的记录，name&age，则会自动比较这两个字段，以确定一对Person对象。|d0dvv|public+record+Person+(+String+name+,+int+age+)+{}|9tfcd|试试看。|4ssaj|Person+alice+=+new+Person(+"Alice"+,+23+)+;
Person+alice2+=+new+Person(+"Alice"+,+23+)+;
Person+bob+=+new+Person(+"Bob"+,+19+)+;

boolean+samePerson1+=+alice.equals(+alice2+)+;++//+true.
boolean+samePerson2+=+alice.equals(+bob+)+;++//+false.|d09ng|你可以重写equals如果需要的行为不是默认行为，则在记录上使用。但是如果你要覆盖equals，请务必覆盖hashCode|8jctr|对于一致的逻辑，如下所示|2aft5|您可以使用传统的Java类。而且，要三思而后行:无论何时将方法添加到record，重新考虑记录结构是否真的适合该问题域。|3b3v3|提示:Arecord可以在另一个类中定义，甚至可以在方法中本地定义。^0|0|0|0|F|2|O|3|0|0|6|0|6|0|0|7|0|A|6|1|0|1H|6|1O|8|1Z|8|0|0|6|0|6|0|5|6|1J|6|0|9|6|P|4|U|3|1F|6|0|0|0|0|5|6|15|6|1H|8|0|0|Y|6|0|4|6^^$0|$1|$2|3|4|5|6|$7|8]]|9|$2|3|4|5|6|$7|A]]]|B|@$C|D|E|F|2|G|H|1P|I|@]|J|@]|6|$]]|$C|K|E|L|2|M|H|1Q|I|@]|J|@]|6|$N|O]]|$C|P|E|Q|2|G|H|1R|I|@]|J|@]|6|$]]|$C|R|E|S|2|G|H|1S|I|@$T|1T|U|1U|V|W]|$T|1V|U|1W|V|W]]|J|@]|6|$]]|$C|X|E|Y|2|Z|H|1X|I|@$T|1Y|U|1Z|V|10]|$T|20|U|21|V|W]]|J|@]|6|$]]|$C|11|E|12|2|G|H|22|I|@]|J|@$T|23|U|24|C|25]|$T|26|U|27|C|28]]|6|$]]|$C|13|E|14|2|G|H|29|I|@$T|2A|U|2B|V|W]|$T|2C|U|2D|V|W]|$T|2E|U|2F|V|W]]|J|@]|6|$]]|$C|15|E|16|2|G|H|2G|I|@$T|2H|U|2I|V|W]|$T|2J|U|2K|V|10]]|J|@]|6|$]]|$C|17|E|18|2|G|H|2L|I|@$T|2M|U|2N|V|W]|$T|2O|U|2P|V|W]]|J|@]|6|$]]|$C|19|E|1A|2|G|H|2Q|I|@$T|2R|U|2S|V|W]|$T|2T|U|2U|V|W]|$T|2V|U|2W|V|W]|$T|2X|U|2Y|V|W]]|J|@]|6|$]]|$C|1B|E|1C|2|M|H|2Z|I|@]|J|@]|6|$N|O]]|$C|1D|E|1E|2|G|H|30|I|@]|J|@]|6|$]]|$C|1F|E|1G|2|M|H|31|I|@]|J|@]|6|$N|O]]|$C|1H|E|1I|2|G|H|32|I|@$T|33|U|34|V|W]|$T|35|U|36|V|W]|$T|37|U|38|V|W]]|J|@]|6|$]]|$C|1J|E|1K|2|G|H|39|I|@]|J|@]|6|$]]|$C|1L|E|1M|2|G|H|3A|I|@$T|3B|U|3C|V|W]]|J|@]|6|$]]|$C|1N|E|1O|2|G|H|3D|I|@$T|3E|U|3F|V|W]]|J|@]|6|$]]]]

<h1>tl;dr</h1>
<pre class="lang-java prettyprint-override"><code>record Person ( String name , int age ) {} 
if( 
 new Person( &quot;Carol&quot; , 27 ) // Compiler auto-generates implicitly the constructor.
 .equals( // Compiler auto-generates implicitly the `equals` method.
 new Person( &quot;Carol&quot; , 42 ) 
 ) 
) // Returns `false`, as the name matches but the age differs.
{ … }
</code></pre>
<h1>Details</h1>
While your specific problem is solved (using <code>==</code> for equality test between <code>int</code> primitive values), there is an alternative that eliminates the need to write that code.
<h1><code>record</code></h1>
<a href="https://en.wikipedia.org/wiki/Java_version_history#Java_SE_16" rel="nofollow noreferrer">Java 16</a> brings the <a href="https://openjdk.java.net/jeps/395" rel="nofollow noreferrer">record</a> feature.
A record is a brief way to write a class whose main purpose is to transparently and immutably carry data. The compiler implicitly creates the constructor, getters, <code>equals</code> &amp; <code>hashCode</code>, and <code>toString</code>.
<h2><code>equals</code> method provided automatically</h2>
The default implicit <code>equals</code> method compares each and every member field that you declared for the record. The members can be objects or primitives, both types are automatically compared in the default <code>equals</code> method.
For example, if you have a <code>Person</code> record carrying two fields, <code>name</code> &amp; <code>age</code>, both of those fields are automatically compared to determine equality between a pair of <code>Person</code> objects.
<pre class="lang-java prettyprint-override"><code>public record Person ( String name , int age ) {}
</code></pre>
Try it.
<pre class="lang-java prettyprint-override"><code>Person alice = new Person( &quot;Alice&quot; , 23 ) ;
Person alice2 = new Person( &quot;Alice&quot; , 23 ) ;
Person bob = new Person( &quot;Bob&quot; , 19 ) ;

boolean samePerson1 = alice.equals( alice2 ) ; // true.
boolean samePerson2 = alice.equals( bob ) ; // false.
</code></pre>
You can override the <code>equals</code> method on a record, if you want a behavior other than the default. But if you do override <code>equals</code>, be sure to override <code>hashCode</code> for consistent logic, as <a href="https://stackoverflow.com/q/27581/642706">you would for a conventional Java class</a>. And, think twice: Whenever adding methods to a <code>record</code>, reconsider if a record structure is really appropriate to that problem domain.
Tip: A <code>record</code> can be defined within another class, and even locally within a method.

I am trying to override equals method in Java. I have a class <code>People</code> which basically has 2 data fields <code>name</code> and <code>age</code>. Now I want to override <code>equals</code> method so that I can check between 2 People objects. 

My code is as follows

<pre><code>public boolean equals(People other){
 boolean result;
 if((other == null) || (getClass() != other.getClass())){
 result = false;
 } // end if
 else{
 People otherPeople = (People)other;
 result = name.equals(other.name) &amp;&amp; age.equals(other.age);
 } // end else

 return result;
} // end equals
</code></pre>

But when I write <code>age.equals(other.age)</code> it gives me error as equals method can only compare String and age is Integer. 

<h2>Solution</h2>

I used <code>==</code> operator as suggested and my problem is solved.

How to override equals method in Java

编译器

Java

 我正在尝试覆盖Java中的equals方法。我有一节课People它基本上有2个数据字段name和age。现在我想覆盖equals方法，这样我就可以在两个People对象之间进行检查。 我的代码如下 public boolean equals(People other){    boolean result;    ...

问如何在Java中重写equals方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中重写equals方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中重写equals方法
EN