因为我猜 age是 int型:

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) &&  age == otherPeople.age;
} // end else


return result;
} // end equals

我不确定细节，因为你还没有发布完整的代码，但是:

• 还要记得覆盖 hashCode()
• equals方法的参数类型应该是 Object，而不是 People。目前您正在重载而不是重写 equals 方法，这可能不是您想要的，特别是考虑到您稍后会检查它的类型。
• 你可以使用 instanceof来检查它是一个 People 对象，例如 if (!(other instanceof People)) { result = false;}
• equals用于所有对象，但不用于原语。我认为你的意思是年龄是一个 int(原语) ，在这种情况下只使用 ==。请注意，整数(大写“ I”)是一个对象，应该与等于。

有关详细信息，请参阅 在 Java 中重写 equals 和 hashCode 时应该考虑哪些问题？。

如果 age 是 int，那么应该使用 = = ，如果是 Integer 对象，那么可以使用 equals ()。 如果重写 equals，还需要实现 hashcode 方法。合同的细节可以在对象的 javadoc 中找到，也可以在 web 的不同页面中找到。

引入一个改变参数类型的新方法签名称为 超载:

public boolean equals(People other){

这里 People不同于 Object。

当一个方法签名与它的超类保持相同时，它被称为 重写，而 @Override注释有助于在编译时区分这两者:

@Override
public boolean equals(Object other){

如果没有看到 age的实际声明，就很难说出错误出现的原因。

//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<Person> people = new ArrayList<Person>();
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++) {
for (int y = i + 1; y <= people.size() - 1; y++) {
boolean check = people.get(i).equals(people.get(y));


System.out.println("-- " + people.get(i).getName() + " - VS - " + 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;
}
}

产出:

运行:

—— Subash Adhikari VS-K false

—— Subash Adhikari-VS-StackOverflow false

—— Subash Adhikari-VS-Subash Adhikari true

—— K-VS-StackOverflow false

—— K-VS-Subash Adhikari 假

—— StackOverflow-VS-Subash Adhikari false

——构建成功(总时间: 0秒)

@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
}

当比较 Java 中的对象时，你要做一个 语义检查，将对象的 类型和识别状态与:

• 本身(同一实例)
• 本身(克隆或重构的副本)
• 其他不同类型的对象
• 同类型的其他对象
• null

规则:

• 对称性 : a.equals(b) == b.equals(a)
• equals()总是产生 true或 false，但从来没有一个 NullpointerException，ClassCastException或任何其他投掷

比较:

• 键入 check : 两个实例都需要是 一样类型，这意味着您必须比较实际的类以获得相等性。当开发人员使用 instanceof进行类型比较时(只有在没有子类的情况下才能正常工作，而且在 A extends B -> a instanceof b != b instanceof a)时违反了对称性规则) ，这通常是不正确实现的。
• 标识状态的语义检查 : 确保您理解标识实例的状态。人们可以通过他们的社会保险号码来识别，但不能通过头发的颜色(可以染色)、姓名(可以改变)或年龄(随时变化)来识别。只有使用值对象才能比较完整状态(所有非瞬态字段) ，否则只检查标识实例的内容。

对于你的 Person课程:

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);
}

可重用的通用实用工具类:

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 <T>            instance type
* @return true when equals, false otherwise
*/
public static <T> boolean as(T instance, Object other, Function<? super T, Object>... 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)));
}
}

对于 Person类，使用以下实用工具类:

public boolean equals(Object obj) {
return Equals.as(this, obj, t -> t.name, t -> t.age);
}

第十条对等时遵守总合同

根据有效的 Java ，重写 equals方法看起来很简单，但是有很多方法会出错，而且后果可能很严重。避免问题的最简单方法是不重写 equals方法，在这种情况下，类的每个实例只等于它自己。如果适用下列任何条件，这是正确的做法:

• 该类的每个实例本质上都是唯一的。对于像 Thread 这样表示活动实体而不是值的类来说，情况是这样的。Object 提供的 equals 实现具有适合这些类的正确行为。

• 该类不需要提供“逻辑相等”测试。例如，java.util.regex。模式可以覆盖 equals 来检查两个模式实例是否表示完全相同的正则表达式，但是设计人员认为客户机不会需要或想要这个功能。在这些情况下，从 Object 继承的 equals 实现是理想的。

• 超类已经覆盖了 equals， ，并且超类的行为适合于这个类。例如，大多数 Set 实现从 AbstractSet 继承它们的等于实现，从 AbstractList 继承 List 实现，从 AbstractMap 继承 Map 实现。

• 该类是 private 或 package-private ，您可以确定永远不会调用它的 equals 方法。如果您非常规避风险，您可以重写 equals 方法，以确保它不会被意外调用: