Java Stream distinct() 行为解析：避免可变对象陷阱

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamDistinctIssue {

    public static void main(String[] args) {
        // 示例1: 使用可变对象 TestBean
        List<TestBean> obj_list = Arrays.asList(new TestBean("aa"), new TestBean("bb"), new TestBean("bb")).stream()
                .distinct() // 期望去重
                .map(tt -> {
                    tt.col = tt.col + "_t"; // 修改了影响 equals/hashCode 的字段
                    return tt;
                }).collect(Collectors.toList());
        System.out.println("TestBean 结果: " + obj_list);

        // 示例2: 使用不可变对象 String
        List<String> string_obj_list = Arrays.asList(new String("1"), new String("2"), new String("2")).stream()
                .distinct()
                .map(t -> t + "_t")
                .collect(Collectors.toList());
        System.out.println("String (New Object) 结果: " + string_obj_list);

        // 示例3: 使用不可变对象 String (字面量)
        List<String> string_list = Arrays.asList("1", "2", "2").stream()
                .distinct()
                .map(t -> t + "_t")
                .collect(Collectors.toList());
        System.out.println("String (Literal) 结果: " + string_list);
    }
}

@Data
@AllArgsConstructor
@EqualsAndHashCode
class TestBean {
    String col;
}

TestBean 结果: [TestBean(col=aa_t), TestBean(col=bb_t), TestBean(col=bb_t)]
String (New Object) 结果: [1_t, 2_t]
String (Literal) 结果: [1_t, 2_t]

import java.util.HashSet;
import java.util.Set;

public class HashSetMutationIssue {

    public static void main(String... args) {
        class MutableTestBean {
            String col;

            MutableTestBean(String col) {
                this.col = col;
            }

            @Override
            public int hashCode() {
                return col.hashCode(); // hashCode 依赖于 col
            }

            @Override
            public boolean equals(Object o) {
                if (this == o) return true;
                if (o == null || getClass() != o.getClass()) return false;
                MutableTestBean that = (MutableTestBean) o;
                return col.equals(that.col); // equals 依赖于 col
            }

            @Override
            public String toString() {
                return "MutableTestBean(col='" + col + "')";
            }
        }

        Set<MutableTestBean> set = new HashSet<>();
        MutableTestBean x = new MutableTestBean("bb");

        for (int i = 0; i < 5; i++) {
            System.out.println("set.add(x)=" + set.add(x)); // 尝试添加同一个对象
            System.out.println("set.size()=" + set.size());
            // 关键：修改了影响 hashCode 和 equals 的字段
            x.col += "_t";
        }
    }
}

// 错误示范（修改原对象）：
.map(tt -> {
    tt.col = tt.col + "_t";
    return tt;
})

// 正确示范（返回新对象）：
.map(tt -> new TestBean(tt.col + "_t"))

// 使用 Java Record 定义 TestBean
record ImmutableTestBean(String col) {}

public class StreamDistinctImmutable {
    public static void main(String[] args) {
        List<ImmutableTestBean> obj_list = Arrays.asList(
                        new ImmutableTestBean("aa"),
                        new ImmutableTestBean("bb"),
                        new ImmutableTestBean("bb"))
                .stream()
                .distinct() // 此时 distinct 可以正常工作
                .map(tt -> new ImmutableTestBean(tt.col() + "_t")) // 创建新对象
                .collect(Collectors.toList());
        System.out.println("ImmutableTestBean 结果: " + obj_list);
        // 预期输出: [ImmutableTestBean[col=aa_t], ImmutableTestBean[col=bb_t]]
    }
}

// 假设 TestBean 的 equals/hashCode 仅基于 id 字段，而 map 操作修改的是 name 字段
// 这种情况下，先 map 后 distinct 可能是可行的
// 但这不是解决上述问题的通用方案，因为上述问题中修改的正是影响 equals/hashCode 的字段
List<TestBean> obj_list = Arrays.asList(new TestBean("aa"), new TestBean("bb"), new TestBean("bb")).stream()
        .map(tt -> {
            tt.col = tt.col + "_t"; // 修改了字段
            return tt;
        })
        .distinct() // distinct 放在 map 之后
        .collect(Collectors.toList());
// 在本例中，这仍然无法解决问题，因为 col 参与了 equals/hashCode