利用stream sorted进行降序排序

2023-07-04 22:24:02 322

根据value值的大小进行降序排序，并进行截取。

publicstaticvoidmain(String[]args){
List>list=Lists.newArrayList();
Mapmap=Maps.newHashMap();
map.put("id",1);
map.put("value",20);
list.add(map);
map=Maps.newHashMap();
map.put("id",2);
map.put("value",80);
list.add(map);
map=Maps.newHashMap();
map.put("id",3);
map.put("value",21);
list.add(map);
map=Maps.newHashMap();
map.put("id",4);
map.put("value",28);
list.add(map);
System.out.println("原始数据："+list);
//根据value进行排序得到升序排列
list.sort(Comparator.comparing(h->ConvertUtil.obj2Integer(h.get("value"))));
//颠倒排序，变为降序排列
Collections.reverse(list);
//截取前3个
System.out.println("结果"+list.subList(0,3));
}

使用1.8stream处理

List>result=list.stream().sorted((h1,h2)->
//降序
ConvertUtil.obj2Integer(h2.get("value")).compareTo(ConvertUtil.obj2Integer(h1.get("value"))))
//前3个
.limit(3)
//终止流
.collect(Collectors.toList());
System.out.println("流结果"+result);

运行结果：

原始数据：

[{id=1,value=20},{id=2,value=80},{id=3,value=21},{id=4,value=28}]

结果

[{id=2,value=80},{id=4,value=28},{id=3,value=21}]

补充：Java8Stream流的sorted()排序===使用Comparator排序

sorted()方法排序，一个是Comparable(自然排序)，一个是Comparator接口，像Integer、String等这些基本类型的包装类已经实现了Comparable接口，

Comparable接口======》java.lang包下的

方法CompareTo(Objecto)，除了基本类型包装类外，一些常用的pojo类要使用CompareTo(Objecto)排序，就要实现Comparable接口，在pojo类里重写compareTo()方法

Comparator接口======》java.util包下的

方法compare(Objecta,Objectb)

关于Comparable和Comparator接口

Sorted排序一共有两种，自然排序和Comparator接口的排序，

使用sorted（)排序

1、简单List排序=====》

packagecom.it.test;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.stream.Collectors;
publicclassStreamTest{
publicstaticvoidmain(String[]args){
Listintegers=newArrayList<>();
integers.add(9);
integers.add(2);
integers.add(0);
integers.add(4);
integers.add(8);
Listcollect=integers.stream().sorted().collect(Collectors.toList());//自然排序
}
}

结果

2、简单List排序

packagecom.it.test;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.stream.Collectors;
publicclassStreamTest{
publicstaticvoidmain(String[]args){
Liststrings=newArrayList<>();
strings.add("aa");
strings.add("b");
strings.add("aac");
strings.add("bb");
strings.add("abb");
Listcollect1=strings.stream().sorted().collect(Collectors.toList());
System.out.println(collect1.toString());
}
}

结果

3、复杂实体对象pojo排序

使用Comparator排序

Person.java

packagecom.it.pojo;
importjava.util.Comparator;
importjava.util.Objects;
@Data
@NoArgsConstructor
@ToString
publicclassPerson{
privateStringname;
privateIntegerage;
}

test.java===>先只根据年龄排序，后先根据年龄排序，再根据姓名排序，都升序

packagecom.it.test;
importjava.util.ArrayList;
importjava.util.List;
importcom.it.pojo.Person;
importjava.util.Comparator;
importjava.util.stream.Collectors;
publicclassStreamTest{
publicstaticvoidmain(String[]args){
Personperson1=newPerson();
person1.setAge(21);
person1.setName("21");

Personperson2=newPerson();
person2.setAge(19);
person2.setName("19");

Personperson3=newPerson();
person3.setAge(19);
person3.setName("20");

Personperson4=newPerson();
person4.setAge(20);
person4.setName("20");

Personperson5=newPerson();
person5.setAge(19);
person5.setName("18");

Listpeople=newArrayList<>();
people.add(person1);
people.add(person2);
people.add(person3);
people.add(person4);
people.add(person5);

Listcollect1=people.stream().sorted((Comparator.comparing(Person::getAge))).collect(Collectors.toList());//只根据年龄排序，升序
System.out.println(collect2);

Listcollect2=people.stream().sorted((Comparator.comparing(Person::getAge)).reversed()).collect(Collectors.toList());//只根据年龄排序，降序
System.out.println(collect2);

Listcollect3=people.stream().sorted((Comparator.comparing(Person::getAge)).thenComparing(Comparator.comparing(Person::getName))).collect(Collectors.toList());//先根据年龄进行排序，遇见相同的，然后根据姓名进行排序，都升序
System.out.println(collect3);

Listcollect4=people.stream().sorted((Comparator.comparing(Person::getAge)).thenComparing(Comparator.comparing(Person::getName)).reversed()).collect(Collectors.toList());/先根据年龄进行排序，遇见相同的，然后根据姓名进行排序，降序【都降序】
System.out.println(collect4);

Listcollect5=people.stream().sorted(Comparator.comparing(Person::getAge).reversed().thenComparing(Comparator.comparing(Person::getName)).reversed()).collect(Collectors.toList());//年龄升序，姓名降序
System.out.println(collect5);

Listcollect6=people.stream().sorted(Comparator.comparing(Person::getAge).reversed().thenComparing(Comparator.comparing(Person::getName))).collect(Collectors.toList());//根据年龄降序，姓名升序
System.out.println(collect6);
}
}

结果

只根据年龄进行排序的，默认是升序

根据年龄降序

先根据年龄，后根据姓名排序的，默认都是升序

根据年龄和性别，先根据年龄，年龄相同根据性别，只在最后一个comparing上写reversed，两个排序都是降序【根据年龄降序，姓名降序】

根据年龄升序，年龄相同，根据姓名降序

总结

先这么着吧

以上为个人经验，希望能给大家一个参考，也希望大家多多支持毛票票。如有错误或未考虑完全的地方，望不吝赐教。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。