在Java开发中，集合去重是常见的操作需求。无论是处理数据库查询结果、API返回的JSON数据，还是业务逻辑中的对象列表，我们经常需要根据对象的某个或多个属性进行去重。本文将详细介绍如何通过自定义distinctByKey方法，结合Java 8的函数式编程特性，实现基于对象属性的高效去重。

一、传统去重方法的局限性

在Java 8之前，集合去重通常有以下几种方式：

重写equals/hashCode方法：这是最基础的方式，但需要修改对象类本身，且当去重条件变化时需要重复修改代码。
使用Set集合：通过将元素添加到Set中实现去重，但同样受限于equals/hashCode方法，且无法灵活指定去重属性。
遍历比较：通过双重循环或维护一个临时列表来检查重复，这种方式时间复杂度高（O(n²)），性能较差。

这些方法在简单场景下可以工作，但在需要灵活指定去重属性或处理复杂对象时显得不够灵活。

二、distinctByKey方法的设计思路

distinctByKey方法的核心思想是：将对象转换为指定的键（属性），然后利用Map的特性来保证键的唯一性。这种方法具有以下优势：

灵活性：可以动态指定去重属性，无需修改对象类
高性能：时间复杂度为O(n)，优于遍历比较方法
可读性：函数式编程风格使代码更简洁

三、方法实现与解析

以下是完整的distinctByKey方法实现：

import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.List;
public class CollectionUtils {
    /**
     * 根据对象属性去重
     * @param keyExtractor 属性提取函数
     * @param <T> 对象类型
     * @return 去重谓词
     */
    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object, Boolean> seen = new java.util.concurrent.ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
    /**
     * 扩展方法：直接对List去重
     * @param list 原始列表
     * @param keyExtractor 属性提取函数
     * @param <T> 对象类型
     * @return 去重后的列表
     */
    public static <T> List<T> distinctByProperty(List<T> list, Function<? super T, ?> keyExtractor) {
        return list.stream()
                .filter(distinctByKey(keyExtractor))
                .collect(Collectors.toList());
    }
}

1. 核心方法解析

distinctByKey方法返回一个Predicate，这个谓词可以用于Stream的filter操作。其工作原理：

创建一个ConcurrentHashMap来记录已见过的键
对于每个元素，使用keyExtractor提取键
使用putIfAbsent方法尝试将键存入Map
如果返回值为null，表示这是第一次见到该键，保留该元素；否则过滤掉

2. 线程安全考虑

使用ConcurrentHashMap而不是普通的HashMap，使得这个谓词可以在并行流中使用：

List<User> distinctUsers = users.parallelStream()
        .filter(distinctByKey(User::getId))
        .collect(Collectors.toList());

3. 扩展方法实现

distinctByProperty方法提供了更便捷的调用方式，直接接收列表和属性提取函数，返回去重后的列表。

四、实际应用示例

假设我们有以下User类：

class User {
    private Long id;
    private String name;
    private String email;
    // 构造方法、getter/setter省略
    @Override
    public String toString() {
        return "User{id=" + id + ", name='" + name + "', email='" + email + "'}";
    }
}

1. 根据ID去重

List<User> users = Arrays.asList(
    new User(1L, "Alice", "alice@example.com"),
    new User(2L, "Bob", "bob@example.com"),
    new User(1L, "Alice", "alice2@example.com") // 重复ID
);
List<User> distinctById = CollectionUtils.distinctByProperty(users, User::getId);
distinctById.forEach(System.out::println);

输出结果将只包含前两个User对象，第三个因ID重复被过滤。

2. 根据Email去重

List<User> distinctByEmail = CollectionUtils.distinctByProperty(users, User::getEmail);
distinctByEmail.forEach(System.out::println);

3. 复合属性去重

如果需要根据多个属性组合去重，可以这样实现：

List<User> distinctByCompositeKey = users.stream()
        .filter(distinctByKey(u -> u.getName() + "|" + u.getEmail()))
        .collect(Collectors.toList());

五、性能分析与优化

1. 时间复杂度分析

每个元素处理时间为O(1)（Map操作）
总体时间复杂度为O(n)
相比双重循环的O(n²)，性能提升显著

2. 内存使用考虑

需要额外存储所有唯一键
对于大集合，考虑键的大小和数量
如果键对象较大，可以考虑使用更紧凑的表示方式

3. 替代实现方案

对于不需要并行处理的场景，可以使用更简单的实现：

public static <T> Predicate<T> distinctByKeySimple(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}

这种实现更简洁，但只能用于非并行流。

六、最佳实践建议

键提取函数的选择：
- 确保提取的键正确反映了去重需求
- 对于可能为null的属性，需要额外处理
性能敏感场景：
- 对于大集合，考虑在提取键前进行预过滤
- 如果键对象较大，考虑使用更紧凑的表示方式
不可变对象：
- 如果处理的是不可变对象，可以考虑缓存键对象
并行流使用：
- 确保使用线程安全的Map实现
- 注意并行流可能带来的开销

七、与其他去重方式的比较

方法	灵活性	性能	代码复杂度	是否需要修改对象类
重写equals/hashCode	低	高	低	是
Set去重	低	高	中	否
遍历比较	高	低	高	否
distinctByKey	高	高	中	否

八、总结与展望

distinctByKey方法提供了一种灵活、高效的方式来根据对象属性进行集合去重。它充分利用了Java 8的函数式编程特性，使得代码更简洁、更易维护。在实际开发中，我们可以根据具体需求选择合适的实现方式，并注意性能优化和线程安全等问题。

随着Java版本的更新，未来可能会有更简洁的实现方式。例如，Java 16引入的Stream.toList()和模式匹配等特性，可能会进一步简化这类操作的实现。但无论如何，理解这种基于Map特性的去重思路，对于掌握函数式编程和集合操作都是非常有益的。

在实际项目中，我们可以将这类工具方法封装到公共工具类中，供整个项目使用，提高代码复用率和开发效率。同时，也可以根据项目特点进行扩展，比如添加日志记录、性能统计等功能，使工具方法更加完善。

Java集合处理：基于属性去重的distinctByKey方法实现