Java 8 Stream.distinct() 列表去重的操作

2023-07-08 16:07:07 338

在这篇文章里，我们将提供Java8Streamdistinct（）示例。distinct（）返回由该流的不同元素组成的流。distinct（）是Stream接口的方法。

distinct（）使用hashCode（）和equals（）方法来获取不同的元素。因此，我们的类必须实现hashCode（）和equals（）方法。

如果distinct（）正在处理有序流，那么对于重复元素，将保留以遭遇顺序首先出现的元素，并且以这种方式选择不同元素是稳定的。

在无序流的情况下，不同元素的选择不一定是稳定的，是可以改变的。distinct（）执行有状态的中间操作。

在有序流的并行流的情况下，保持distinct（）的稳定性是需要很高的代价的，因为它需要大量的缓冲开销。如果我们不需要保持遭遇顺序的一致性，那么我们应该可以使用通过BaseStream.unordered（）方法实现的无序流。

1.Stream.distinct()

distinct()方法的声明如下：

Streamdistinct()

它是Stream接口的方法。在此示例中，我们有一个包含重复元素的字符串数据类型列表

DistinctSimpleDemo.java

packagecom.concretepage;
importjava.util.Arrays;
importjava.util.List;
importjava.util.stream.Collectors;
publicclassDistinctSimpleDemo{
publicstaticvoidmain(String[]args){
Listlist=Arrays.asList("AA","BB","CC","BB","CC","AA","AA");
longl=list.stream().distinct().count();
System.out.println("No.ofdistinctelements:"+l);
Stringoutput=list.stream().distinct().collect(Collectors.joining(","));
System.out.println(output);
}
}

Output

No.ofdistinctelements:3

AA,BB,CC

2.Stream.distinct()withListofObjects

在此示例中，我们有一个Book对象列表。为了对列表进行去重，该类将重写hashCode（）和equals（）。

Book.java

packagecom.concretepage;
publicclassBook{
privateStringname;
privateintprice;
publicBook(Stringname,intprice){
this.name=name;
this.price=price;
}
publicStringgetName(){
returnname;
}
publicintgetPrice(){
returnprice;
}
@Override
publicbooleanequals(finalObjectobj){
if(obj==null){
returnfalse;
}
finalBookbook=(Book)obj;
if(this==book){
returntrue;
}else{
return(this.name.equals(book.name)&&this.price==book.price);
}
}
@Override
publicinthashCode(){
inthashno=7;
hashno=13*hashno+(name==null?0:name.hashCode());
returnhashno;
}
}

DistinctWithUserObjects.java

packagecom.concretepage;
importjava.util.ArrayList;
importjava.util.List;
publicclassDistinctWithUserObjects{
publicstaticvoidmain(String[]args){
Listlist=newArrayList<>();
{
list.add(newBook("CoreJava",200));
list.add(newBook("CoreJava",200));
list.add(newBook("LearningFreemarker",150));
list.add(newBook("SpringMVC",300));
list.add(newBook("SpringMVC",300));
}
longl=list.stream().distinct().count();
System.out.println("No.ofdistinctbooks:"+l);
list.stream().distinct().forEach(b->System.out.println(b.getName()+","+b.getPrice()));
}
}

Output

No.ofdistinctbooks:3
CoreJava,200
LearningFreemarker,150
SpringMVC,300

3.DistinctbyProperty

distinct（）不提供按照属性对对象列表进行去重的直接实现。它是基于hashCode（）和equals（）工作的。

如果我们想要按照对象的属性，对对象列表进行去重，我们可以通过其它方法来实现。

如下代码段所示：

staticPredicatedistinctByKey(FunctionkeyExtractor){
Mapseen=newConcurrentHashMap<>();
returnt->seen.putIfAbsent(keyExtractor.apply(t),Boolean.TRUE)==null;
}

上面的方法可以被Stream接口的filter()接收为参数，如下所示：

list.stream().filter(distinctByKey(b->b.getName()));

distinctByKey()方法返回一个使用ConcurrentHashMap来维护先前所见状态的Predicate实例，如下是一个完整的使用对象属性来进行去重的示例。

DistinctByProperty.java

packagecom.concretepage;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Map;
importjava.util.concurrent.ConcurrentHashMap;
importjava.util.function.Function;
importjava.util.function.Predicate;
publicclassDistinctByProperty{
publicstaticvoidmain(String[]args){
Listlist=newArrayList<>();
{
list.add(newBook("CoreJava",200));
list.add(newBook("CoreJava",300));
list.add(newBook("LearningFreemarker",150));
list.add(newBook("SpringMVC",200));
list.add(newBook("Hibernate",300));
}
list.stream().filter(distinctByKey(b->b.getName()))
.forEach(b->System.out.println(b.getName()+","+b.getPrice()));
}
privatestaticPredicatedistinctByKey(FunctionkeyExtractor){
Mapseen=newConcurrentHashMap<>();
returnt->seen.putIfAbsent(keyExtractor.apply(t),Boolean.TRUE)==null;
}
}

Output

CoreJava,200
LearningFreemarker,150
SpringMVC,200
Hibernate,300

from:https://www.concretepage.com/java/jdk-8/java-8-distinct-example

补充知识：List集合常规去重与java8新特性去重方法

一、常规去重

碰到List去重的问题，除了遍历去重，我们常常想到利用Set集合不允许重复元素的特点，通过List和Set互转，来去掉重复元素。

//遍历后判断赋给另一个list集合，保持原来顺序
publicstaticvoidridRepeat1(Listlist){
System.out.println("list=["+list+"]");
ListlistNew=newArrayList();
for(Stringstr:list){
if(!listNew.contains(str)){
listNew.add(str);
}
}
System.out.println("listNew=["+listNew+"]");
}
//set集合去重，保持原来顺序
publicstaticvoidridRepeat2(Listlist){
System.out.println("list=["+list+"]");
ListlistNew=newArrayList();
Setset=newHashSet();
for(Stringstr:list){
if(set.add(str)){
listNew.add(str);
}
}
System.out.println("listNew=["+listNew+"]");
}
//Set去重由于Set的无序性，不会保持原来顺序
publicstaticvoidridRepeat3(Listlist){
System.out.println("list=["+list+"]");
Setset=newHashSet();
ListlistNew=newArrayList();
set.addAll(list);
listNew.addAll(set);
System.out.println("listNew=["+listNew+"]");
}
//Set去重（将ridRepeat3方法缩减为一行）无序
publicstaticvoidridRepeat4(Listlist){
System.out.println("list=["+list+"]");
ListlistNew=newArrayList(newHashSet(list));
System.out.println("listNew=["+listNew+"]");
}
//Set去重并保持原先顺序
publicstaticvoidridRepeat5(Listlist){
System.out.println("list=["+list+"]");
ListlistNew2=newArrayList(newLinkedHashSet(list));
System.out.println("listNew=["+listNew+"]");
}

二、java8的stream写法实现去重

1、distinct去重

//利用java8的stream去重
ListuniqueList=list.stream().distinct().collect(Collectors.toList());
System.out.println(uniqueList.toString());

distinct()方法默认是按照父类Object的equals与hashCode工作的。所以：

上面的方法在List元素为基本数据类型及String类型时是可以的，但是如果List集合元素为对象，却不会奏效。不过如果你的实体类对象使用了目前广泛使用的lombok插件相关注解如：@Data,那么就会自动帮你重写了equals与hashcode方法，当然如果你的需求是根据某几个核心字段属性判断去重，那么你就要在该类中自定义重写equals与hashcode方法了。

2、也可以通过新特性简写方式实现

不过该方式不能保持原列表顺序而是使用了TreeSet按照字典顺序排序后的列表，如果需求不需要按原顺序则可直接使用。

//根据name属性去重
Listlt=list.stream().collect(
collectingAndThen(
toCollection(()->newTreeSet<>(Comparator.comparing(User::getName))),ArrayList::new));
System.out.println("去重后的:"+lt);
//根据name与address属性去重
Listlt1=list.stream().collect(
collectingAndThen(
toCollection(()->newTreeSet<>(Comparator.comparing(o->o.getName()+";"+o.getAddress()))),ArrayList::new));
System.out.println("去重后的:"+lt);

当需求中明确有排序要求也可以按上面简写方式再次加工处理使用stream流的sorted()相关API写法。

Listlt=list.stream().collect(
collectingAndThen(
toCollection(()->newTreeSet<>(Comparator.comparing(User::getName))),v->v.stream().sorted().collect(Collectors.toList())));

3、通过filter()方法

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

privatestaticPredicatedistinctByKey(FunctionkeyExtractor){
Set

Java 8 Stream.distinct() 列表去重的操作

热门推荐

随机推荐