java - unique() 方法不返回 HashSet 元素流的不同元素

Question

假设我有 Employee 类，该类具有正确重写的 equals 和 hashcode 方法。

public class Employee {

private int eno;
private String firstName;
private String lastName;

@Override
public int hashCode() {
    System.out.println("hashcode called");
    final int prime = 31;
    int result = 1;
    result = prime * result + eno;
    result = prime * result + ((firstName == null) ? 0 : firstName.hashCode());
    result = prime * result + ((lastName == null) ? 0 : lastName.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    System.out.println("equals called");
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Employee other = (Employee) obj;
    if (eno != other.eno)
        return false;
    if (firstName == null) {
        if (other.firstName != null)
            return false;
    } else if (!firstName.equals(other.firstName))
        return false;
    if (lastName == null) {
        if (other.lastName != null)
            return false;
    } else if (!lastName.equals(other.lastName))
        return false;
    return true;
}
}

测试类如下

class Test {

    public static void main(String[] args) {

        Employee e1 = new Employee(1, "Karan", "Mehara");
        Employee e2 = new Employee(2, "Rajesh", "Shukla");

        Set<Employee> emps= new HashSet<>();
        emps.add(e1);
        emps.add(e2);
        System.out.println(emps);

        // No such requirement just for testing purpose modifying 
        e2.setEno(1);
        e2.setFirstName("Karan");
        e2.setLastName("Mehara");

        System.out.println(emps);

        emps.stream().distinct().forEach(System.out::println);
    }

}

上述程序的输出为:

[员工 [eno=1，firstName=Karan，lastName=Mehara]，员工 [eno=2，firstName=Rajesh，lastName=Shukla]]

[员工 [eno=1，firstName=Karan，lastName=Mehara]，员工 [eno=1，firstName=Karan，lastName=Mehara]]

员工 [eno=1，firstName=Karan，lastName=Mehara]

员工 [eno=1，firstName=Karan，lastName=Mehara]

为什么distinct()方法返回重复元素？

根据employee类的equals()和hashcode()方法，这两个对象是相同的。

我观察到，当我调用 unique() 方法 equals() 和 hashcode() 方法时，不会获得对 Set 实现流的调用，但它接到电话以获取列表实现流。

根据 JavaDoc 的说法unique() 返回一个由该流的不同元素(根据 Object.equals(Object)) 组成的流。

/**
     * Returns a stream consisting of the distinct elements (according to
     * {@link Object#equals(Object)}) of this stream.
     *
     * <p>For ordered streams, the selection of distinct elements is stable
     * (for duplicated elements, the element appearing first in the encounter
     * order is preserved.)  For unordered streams, no stability guarantees
     * are made.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">stateful
     * intermediate operation</a>.
     *
     * @apiNote
     * Preserving stability for {@code distinct()} in parallel pipelines is
     * relatively expensive (requires that the operation act as a full barrier,
     * with substantial buffering overhead), and stability is often not needed.
     * Using an unordered stream source (such as {@link #generate(Supplier)})
     * or removing the ordering constraint with {@link #unordered()} may result
     * in significantly more efficient execution for {@code distinct()} in parallel
     * pipelines, if the semantics of your situation permit.  If consistency
     * with encounter order is required, and you are experiencing poor performance
     * or memory utilization with {@code distinct()} in parallel pipelines,
     * switching to sequential execution with {@link #sequential()} may improve
     * performance.
     *
     * @return the new stream
     */
    Stream<T> distinct();

Answer 1

集合是 defined是“不包含重复元素的集合”。因此，Stream 的 set 的 distinct 方法很可能被实现为不执行任何操作，因为它已经保证了值是唯一的.

Javadoc 中明确提到了您所做的事情:

Note: Great care must be exercised if mutable objects are used as set elements. The behavior of a set is not specified if the value of an object is changed in a manner that affects equals comparisons while the object is an element in the set. A special case of this prohibition is that it is not permissible for a set to contain itself as an element.