Java基础教程（190）函数式编程之Stream去重：告别重复！Java Stream去重全攻略，让你的数据集独一无二

本文深度剖析Java Stream数据去重的多种技术方案，从基本类型到复杂对象，为你呈现最全面、最实用的去重方法论。

一、基础去重：distinct()方法

distinct() 是Stream API提供的直接去重方法，适用于简单数据类型和已正确重写hashCode()与equals()方法的对象。

// 字符串去重
List<String> names = Arrays.asList("张三", "李四", "张三", "王五");
List<String> distinctNames = names.stream()
        .distinct()
        .collect(Collectors.toList());
// 结果: [张三, 李四, 王五]

// 整数去重
List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 1);
List<Integer> distinctNumbers = numbers.stream()
        .distinct()
        .collect(Collectors.toList());
// 结果: [1, 2, 3, 4]

二、基于条件的去重：filter()方法

当需要根据业务逻辑进行条件去重时，可使用filter()方法配合自定义条件实现灵活去重。

// 保留首次出现的元素
List<String> list = Arrays.asList("A", "B", "A", "C", "B");
List<String> result = list.stream()
        .filter(new HashSet<>()::add)
        .collect(Collectors.toList());
// 结果: [A, B, C]

// 根据索引条件去重
List<String> items = Arrays.asList("A", "B", "C", "A", "D");
Set<Integer> seenIndexes = new HashSet<>();
List<String> uniqueItems = IntStream.range(0, items.size())
        .filter(i -> seenIndexes.add(items.get(i).hashCode()))
        .mapToObj(items::get)
        .collect(Collectors.toList());
// 结果: [A, B, C, D]

三、使用Collectors.toSet()自动去重

利用Set集合天生不允许重复元素的特性，可以轻松实现去重。

List<String> duplicates = Arrays.asList("Java", "Python", "Java", "C++");
Set<String> uniqueSet = duplicates.stream()
        .collect(Collectors.toSet());
// 结果: [Java, Python, C++] (顺序可能不同)

// 保持顺序的Set去重
List<String> orderedUnique = duplicates.stream()
        .collect(Collectors.toCollection(LinkedHashSet::new))
        .stream().collect(Collectors.toList());
// 结果: [Java, Python, C++] (保持原顺序)

四、按对象属性去重：复杂对象去重方案

处理对象集合时，经常需要根据特定属性进行去重，以下是几种实用方法。

方法1：使用TreeSet按属性去重

// 用户对象示例
class User {
    private Long id;
    private String name;
    private String email;
    
    // 构造方法、getters、toString等省略
}

List<User> users = Arrays.asList(
    new User(1L, "张三", "zhangsan@email.com"),
    new User(2L, "李四", "lisi@email.com"),
    new User(1L, "张三", "zhangsan123@email.com") // 相同ID，不同邮箱
);

// 按ID属性去重
List<User> uniqueUsers = users.stream()
        .collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> 
                    new TreeSet<>(Comparator.comparing(User::getId))),
                ArrayList::new));

方法2：使用自定义收集器按属性去重

// 使用filter和ConcurrentHashMap实现线程安全去重
List<User> distinctByName = users.stream()
        .filter(distinctByKey(User::getName))
        .collect(Collectors.toList());

// 去重工具方法
private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Map<Object, Boolean> seen = new ConcurrentHashMap<>();
    return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}

方法3：使用Vavr库的函数式去重

// 使用Vavr的Stream API（需添加依赖）
// List<User> distinctUsers = List.ofAll(users)
//        .distinctBy(User::getName)
//        .toJavaList();

五、性能比较与最佳实践

1. distinct()：最简单，适用于简单场景，内部使用HashSet
2. TreeSet：保证顺序，但性能相对较低（O(n log n)）
3. ConcurrentHashMap：线程安全，性能较好
4. 自定义过滤器：最灵活，可控制去重逻辑

最佳实践建议：

• 小数据集：优先使用distinct()，代码简洁
• 需要按属性去重：使用TreeSet或自定义过滤器
• 大数据集：考虑使用并行流提升性能
• 需要保持顺序：使用LinkedHashSet

六、完整示例代码

public class StreamDistinctExample {
    public static void main(String[] args) {
        // 创建测试数据
        List<User> users = Arrays.asList(
            new User(1L, "张三", "zhangsan@email.com"),
            new User(2L, "李四", "lisi@email.com"),
            new User(3L, "王五", "wangwu@email.com"),
            new User(1L, "张三", "zhangsan123@email.com"),
            new User(4L, "李四", "lisi456@email.com")
        );
        
        System.out.println("原始数据: " + users);
        
        // 按ID去重
        List<User> distinctById = users.stream()
                .collect(Collectors.collectingAndThen(
                        Collectors.toCollection(() -> 
                            new TreeSet<>(Comparator.comparing(User::getId))),
                        ArrayList::new));
        System.out.println("按ID去重: " + distinctById);
        
        // 按姓名去重
        List<User> distinctByName = users.stream()
                .filter(distinctByKey(User::getName))
                .collect(Collectors.toList());
        System.out.println("按姓名去重: " + distinctByName);
    }
    
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
}

掌握这些去重技巧，能够让你在处理Java集合数据时游刃有余，写出更加简洁、高效的代码。根据具体场景选择最适合的去重方法，是提升代码质量的重要一步。