重写equals和hashcode方法

重写equals和hashcode方法是为了确保对象在比较和哈希时能够正确地工作。equals方法用于比较两个对象是否相等，而hashcode方法用于生成对象的哈希码。在重写这两个方法时，需要遵循以下原则：

1. equals方法必须满足自反性、对称性、传递性和一致性。

2. 如果两个对象相等，则它们的哈希码必须相等。

3. 如果两个对象的哈希码相等，则它们不一定相等。

4. equals方法中使用的字段必须是不可变的。

5. hashcode方法必须使用相同的字段来计算哈希码。

6. 如果一个类重写了equals方法，则必须同时重写hashcode方法。

7. 重写equals方法时，需要考虑null值的情况。

8. 重写hashcode方法时，需要确保生成的哈希码尽可能均匀分布。

总之，重写equals和hashcode方法是为了确保对象在比较和哈希时能够正确地工作，从而避免出现不必要的错误和问题。

相关问题

重写 equals 和 hashCode 方法

重写 equals 和 hashCode 方法的目的是为了比较两个对象是否相等，以及将对象放入散列表中。以下是一个示例：

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

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

在此示例中，equals 方法比较了两个对象的姓名和年龄是否相等，如果相等则返回 true，否则返回 false。hashCode 方法使用 Objects 类的静态方法 hash，将对象的姓名和年龄组合成一个哈希码，用于将对象放入散列表中。

需要注意的是，重写 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，多次调用 x.equals(y) 应该始终返回相同的结果。

5. 对于任何非空引用 x，x.equals(null) 应该返回 false。

对象怎么重写equals和hashcode方法 然后用.distinct()去重

在 Java 中，equals 和 hashCode 方法用于比较对象的值和哈希码。如果两个对象的值相等，它们应该具有相同的哈希码。因此，如果你要使用 .distinct() 方法去重，你需要重写这两个方法。

重写 equals 方法：

1. 比较两个对象的引用是否相等，如果相等，则返回 true。
2. 检查对象是否为 null 或者类型是否不同，如果是，则返回 false。
3. 将对象转换为需要比较的类型，并比较它们的每个字段是否相同，如果所有字段都相同，则返回 true，否则返回 false。

示例代码：

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    MyClass myClass = (MyClass) o;
    return Objects.equals(field1, myClass.field1) && Objects.equals(field2, myClass.field2);
}

重写 hashCode 方法：

1. 声明一个 int 类型的变量 result，并将其初始化为一个非零奇数。
2. 将对象的每个字段的哈希码与 result 进行异或操作。
3. 返回 result。

示例代码：

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + Objects.hashCode(field1);
    result = 31 * result + Objects.hashCode(field2);
    return result;
}

重写完这两个方法后，就可以使用 .distinct() 方法去重了。例如：

List<MyClass> list = new ArrayList<>();
list.add(new MyClass("a", 1));
list.add(new MyClass("b", 2));
list.add(new MyClass("a", 1));
list.add(new MyClass("c", 3));
List<MyClass> distinctList = list.stream().distinct().collect(Collectors.toList());

在这个例子中，我们创建了一个包含四个 MyClass 对象的列表。由于前两个对象的值相同，我们使用 .distinct() 方法去重后，只剩下三个对象。