Java中的equals()方法及其示例

Java中的equals()方法用于比较两个对象是否相等。它是Object类中的方法，子类可以重写该方法来实现自己的比较规则。本文将详细介绍Java中equals()方法的使用和注意事项，并提供示例代码。

equals()方法的基本使用

在Java中，使用equals()方法比较对象相等时，需要注意以下几点：

如果两个对象具有相同的引用，则equals()方法返回真。
如果两个对象的引用不相同，但它们的内容相同，则equals()方法也应返回真。
如果两个对象的引用不相同，并且它们的内容不同，则equals()方法应返回假。

下面我们通过示例代码来说明这些概念。

class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("Tom", 18);
        Student s2 = new Student("Tom", 18);
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1 == s2); // false
    }
}

在上面的示例中，我们定义了一个Student类，并重写了equals()方法。在equals()方法中，我们首先检查传入的对象是否与this引用相同，如果是，则返回真。然后我们检查传入的对象是否为null，是否与this引用属于不同的类，如果是，则返回假。最后，我们比较name和age属性是否相同，如果都相同，则返回真。

在main方法中，我们创建了两个Student对象，它们的内容完全相同，但引用不同。我们使用equals()方法和运算符来比较它们是否相等。由于equals()方法比较的是内容，因此返回了真；而运算符比较的是引用，因此返回了假。

equals()方法的注意事项

在使用equals()方法比较对象相等时，还需要注意以下几点：

equals()方法必须满足自反性、对称性、传递性和一致性四个条件。也就是说，如果a.equals(b)返回真，则b.equals(a)也应该返回真；如果a.equals(b)和b.equals(c)都返回真，则a.equals(c)也应该返回真；如果对象的内容没有发生改变，则多次调用equals()方法应该返回相同的结果。
equals()方法参数必须为Object类型，因为Object是所有类的父类。
equals()方法可以被重写。

下面我们再通过示例代码来说明这些注意事项。

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 o) {
        if (o != null && o.getClass() == getClass()) {
            Person p = (Person) o;
            return name.equals(p.name) && age == p.age;
        }
        return false;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Tom", 18);
        Person p2 = new Person("Tom", 18);
        System.out.println(p1.equals(p2)); // false
        System.out.println(p2.equals(p1)); // false
    }
}

在上面的示例中，我们定义了一个Person类，并重写了equals()方法。在equals()方法中，我们比较name和age属性是否相同，如果相同，则返回真。但是我们没有考虑自反性，由于p.getClass() getClass()的判断，只有当两个对象的类完全相同时equals()方法才会比较它们的内容。因此，我们只考虑了从当前类开始到Object类之间的继承关系，却忽略了可能存在的子类。所以，p1.equals(p2)和p2.equals(p1)都返回了假。

为了避免这个问题，我们应该使用instanceof运算符来进行类型检查。

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 o) {
        if (this == o) return true;
        if (o instanceof Person) {
            Person p = (Person) o;
            return name.equals(p.name) && age == p.age;
        }
        return false;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Tom", 18);
        Person p2 = new Person("Tom", 18);
        System.out.println(p1.equals(p2)); // true
        System.out.println(p2.equals(p1)); // true
    }
}

在上面的示例中，我们使用了this o判断两个引用是否相等，并使用instanceof运算符来进行类型检查。这样，即使子类继承了Person类并且重写了equals()方法，也不会影响到我们的比较结果。