Java8 通过 Stream 多种方式对列表去重

几种列表去重的方法

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 某个属性去重

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"}]
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 在 Java 中,可以使用以下几种方式实现 List 去重: 1. 利用 Set 去重。将 List 中的元素存放到 Set 中,自动去除重复元素,然后再将 Set 转换回 List。示例代码: ```java List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4); List<Integer> newList = new ArrayList<>(new HashSet<>(list)); System.out.println(newList); // [1, 2, 3, 4] ``` 2. 利用 Java 8 中的 Stream 去重。利用 Stream 的 distinct() 方法对 List 进行去重。示例代码: ```java List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4); List<Integer> newList = list.stream().distinct().collect(Collectors.toList()); System.out.println(newList); // [1, 2, 3, 4] ``` 3. 利用循环遍历去重。利用双重循环遍历 List,将重复的元素删除。示例代码: ```java List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4); for (int i = 0; i < list.size() - 1; i++) { for (int j = i + 1; j < list.size(); j++) { if (list.get(i).equals(list.get(j))) { list.remove(j); j--; } } } System.out.println(list); // [1, 2, 3, 4] ``` 以上三种方法都可以实现 List 去重,具体使用哪一种方法可以根据实际情况选择。 ### 回答2: 在Java中,可以使用以下几种方式List进行去重: 1. 使用Set集合:将List作为参数传递给Set的构造函数,然后再将Set转换回List。由于Set的元素不能重复,这样就能实现去重的效果。 ```java List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("A"); list.add("C"); Set<String> set = new LinkedHashSet<>(list); List<String> distinctList = new ArrayList<>(set); System.out.println(distinctList); // 输出:[A, B, C] ``` 2. 使用Java 8的Stream API:通过使用Java 8引入的流操作,我们可以很方便地对List进行去重。 ```java List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("A"); list.add("C"); List<String> distinctList = list.stream().distinct().collect(Collectors.toList()); System.out.println(distinctList); // 输出:[A, B, C] ``` 这里使用了`distinct()`方法来去除重复的元素,并使用`collect(Collectors.toList())`将流转换为List。 3. 自定义比较器:如果要对自定义对象的List进行去重,可以通过自定义对象的`equals()`和`hashCode()`方法来实现去重的逻辑。 ```java class Person { private String name; public Person(String name) { this.name = name; } public String getName() { return name; } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } Person person = (Person) obj; return Objects.equals(name, person.getName()); } @Override public int hashCode() { return Objects.hash(name); } } List<Person> list = new ArrayList<>(); list.add(new Person("John")); list.add(new Person("Mary")); list.add(new Person("John")); List<Person> distinctList = list.stream().distinct().collect(Collectors.toList()); System.out.println(distinctList); // 输出:[John, Mary] ``` 这里重写了`Person`类的`equals()`和`hashCode()`方法,通过比较对象的`name`属性来判断是否相等,从而实现了去重的效果。 ### 回答3: JavaList去重方式多种。 1. 使用Set:将List转化为Set,Set特性是不允许重复元素的,所以会自动去除List中的重复元素。然后将Set再转化回List即可实现去重。 ```java List<Integer> list = new ArrayList<Integer>(); // 原始List // 添加元素到list... Set<Integer> set = new HashSet<Integer>(list); // 将List转为Set,去除重复元素 List<Integer> dedupList = new ArrayList<Integer>(set); // 将Set转为List ``` 2. 使用Java 8的Stream:利用Stream的distinct()方法,可以根据元素的自然顺序或指定的比较器,去重List中的元素。 ```java List<Integer> list = new ArrayList<Integer>(); // 原始List // 添加元素到list... List<Integer> dedupList = list.stream().distinct().collect(Collectors.toList()); // 利用Stream去重 ``` 3. 使用Apache Commons Collections工具类:使用CollectionUtils工具类的removeDuplicates()方法,可以去除List中的重复元素。 ```java List<Integer> list = new ArrayList<Integer>(); // 原始List // 添加元素到list... CollectionUtils.removeDuplicates(list); // 去除List中的重复元素 ``` 这些方法都可以实现List去重,具体根据使用环境和需求选择适合的方法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值