总阅读量:次

⭐⭐⭐ Spring Boot 项目实战 ⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 juejin.cn/post/6844903842132262926 「lq木头」欢迎转载，保留摘要，谢谢！

🙂🙂🙂关注**微信公众号：【芋道源码】**有福利：

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
  4. 新的源码解析文章实时收到通知。每周更新一篇左右。
  5. 认真的源码交流微信群。

在这里我来分享几种列表去重的方法，算是一次整理吧，如有纰漏，请不吝赐教。

1. Stream 的distinct()方法

distinct()是Java 8 中 Stream 提供的方法，返回的是由该流中不同元素组成的流。distinct()使用 hashCode() 和 eqauls() 方法来获取不同的元素。

因此，需要去重的类必须实现 hashCode() 和 equals() 方法。换句话讲，我们可以通过重写定制的 hashCode() 和 equals() 方法来达到某些特殊需求的去重。

distinct() 方法声明如下：

Stream<T> distinct();

1.1 对于 String 列表的去重

因为 String 类已经覆写了 equals() 和 hashCode() 方法，所以可以去重成功。

@Test
public void listDistinctByStreamDistinct() {
  // 1. 对于 String 列表去重
  List<String> stringList = new ArrayList<String>() {{
    add("A");
    add("A");
    add("B");
    add("B");
    add("C");
  }};
  out.print("去重前：");
  for (String s : stringList) {
    out.print(s);
  }
  out.println();
  stringList = stringList.stream().distinct().collect(Collectors.toList());
  out.print("去重后：");
  for (String s : stringList) {
    out.print(s);
  }
  out.println();
}

结果如下：

去重前：AABBC
去重后：ABC

1.2 对于实体类列表的去重

注：代码中我们使用了 Lombok 插件的 @Data注解，可自动覆写 equals() 以及 hashCode() 方法。

/**
* 定义一个实体类
*/
@Data
public class Student {
  private String stuNo;
  private String name;
}

@Test
public void listDistinctByStreamDistinct() throws JsonProcessingException {
    ObjectMapper objectMapper = new ObjectMapper();
    // 1. 对于 Student 列表去重
    List<Student> studentList = getStudentList();
    out.print("去重前：");
    out.println(objectMapper.writeValueAsString(studentList));
    studentList = studentList.stream().distinct().collect(Collectors.toList());
    out.print("去重后：");
    out.println(objectMapper.writeValueAsString(studentList));
  }

结果如下：

去重前：[{"stuNo":"001","name":"Tom"},{"stuNo":"002","name":"Mike"},{"stuNo":"001","name":"Tom"}]
去重后：[{"stuNo":"001","name":"Tom"},{"stuNo":"002","name":"Mike"}]

2. 根据List<Object>中 Object 某个属性去重

2.1 新建一个列表出来

@Test
public void distinctByProperty1() throws JsonProcessingException {
  // 这里第一种方法我们通过新创建一个只有不同元素列表来实现根据对象某个属性去重
  ObjectMapper objectMapper = new ObjectMapper();
  List<Student> studentList = getStudentList();

  out.print("去重前        :");
  out.println(objectMapper.writeValueAsString(studentList));
  studentList = studentList.stream().distinct().collect(Collectors.toList());
  out.print("distinct去重后:");
  out.println(objectMapper.writeValueAsString(studentList));
  // 这里我们引入了两个静态方法，以及通过 TreeSet<> 来达到获取不同元素的效果
  // 1. import static java.util.stream.Collectors.collectingAndThen;
  // 2. import static java.util.stream.Collectors.toCollection;
  studentList = studentList.stream().collect(
    collectingAndThen(
      toCollection(() -> new TreeSet<>(Comparator.comparing(Student::getName))), ArrayList::new)
  );
  out.print("根据名字去重后 :");
  out.println(objectMapper.writeValueAsString(studentList));
}

结果如下：

去重前        :[{"stuNo":"001","name":"Tom"},{"stuNo":"001","name":"Tom"},{"stuNo":"003","name":"Tom"}]
distinct去重后:[{"stuNo":"001","name":"Tom"},{"stuNo":"003","name":"Tom"}]
根据名字去重后 :[{"stuNo":"001","name":"Tom"}]

2.2 通过 filter() 方法

我们首先创建一个方法作为 Stream.filter() 的参数，其返回类型为 Predicate，原理就是判断一个元素能否加入到 Set 中去，代码如下：

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

使用如下：

@Test
public void distinctByProperty2() throws JsonProcessingException {
  // 这里第二种方法我们通过过滤来实现根据对象某个属性去重
  ObjectMapper objectMapper = new ObjectMapper();
  List<Student> studentList = getStudentList();

  out.print("去重前        :");
  out.println(objectMapper.writeValueAsString(studentList));
  studentList = studentList.stream().distinct().collect(Collectors.toList());
  out.print("distinct去重后:");
  out.println(objectMapper.writeValueAsString(studentList));
  // 这里我们将 distinctByKey() 方法作为 filter() 的参数，过滤掉那些不能加入到 set 的元素
  studentList = studentList.stream().filter(distinctByKey(Student::getName)).collect(Collectors.toList());
  out.print("根据名字去重后 :");
  out.println(objectMapper.writeValueAsString(studentList));
}

结果如下：

去重前        :[{"stuNo":"001","name":"Tom"},{"stuNo":"001","name":"Tom"},{"stuNo":"003","name":"Tom"}]
distinct去重后:[{"stuNo":"001","name":"Tom"},{"stuNo":"003","name":"Tom"}]
根据名字去重后 :[{"stuNo":"001","name":"Tom"}]

3. 总结

以上便是我要分享的几种关于列表去重的方法，当然这里没有进行更为详尽的性能分析，希望以后会深入底层再重新分析一下。如有纰漏，还望不吝赐教。在这里我来分享几种列表去重的方法，算是一次整理吧，如有纰漏，请不吝赐教。

文章目录
  1. 1. 1. Stream 的distinct()方法
    1. 1.1. 1.1 对于 String 列表的去重
    2. 1.2. 1.2 对于实体类列表的去重
  2. 2. 2. 根据List<Object>中 Object 某个属性去重
    1. 2.1. 2.1 新建一个列表出来
    2. 2.2. 2.2 通过 filter() 方法
  3. 3. 3. 总结