使用list stream:对List中的对象先进行排序再获取前n个对象

使用list stream:对List中的对象先进行排序再获取前n个对象

目录list stream:对List中的对象先进行排序再获取前n个对象接下来我们就来看一下这个方法通过自定义一个的对象比较方法来进行排序将上面实例中的TestUser对象贴出来对List集合中的对象进行按某个属性排序这里先举一个简单的例子

list stream:对List中的对象先进行排序再获取前n个对象

开发中我们经常会对一个List中的对象进行排序，使用排序后的结果来进行计算或使用，今天来介绍一个非常简洁的对List中对象进行排序，排序后的结果我们只获取前N个对象

接下来我们就来看一下这个方法

List integerList = new ArrayList<>();

integerList.add(2);

integerList.add(3);

integerList.add(10);

integerList.add(5);

System.out.println(integerList.stream().sorted().limit(2).collect(Collectors.toList()));

上面是一个最简单的例子，我们将一个整数List中的每一个数通过默认的排序方法进行排序，排序完成后，只获取这个结果中的前两个数。

下面在来看一个稍微复杂一些的

通过自定义一个的对象比较方法来进行排序

List testUserList = new ArrayList<>();

TestUser testUserOne = TestUser.builder().id(1).age(10.0).name("one").build();

testUserList.add(testUserOne);

TestUser testUserTwo = TestUser.builder().id(2).age(20.0).name("two").build();

testUserList.add(testUserTwo);

TestUser testUserThree = TestUser.builder().id(3).age(15.0).name("three").build();

testUserList.add(testUserThree);

System.out.println(testUserList.stream().sorted(Comparator.comparing(TestUser::getAge)).limit(2).collect(Collectors.toMap(TestUser::getId, TestUser -> TestUser)));

上面的这个例子是将TestUser组成的List进行排序，我们排序的标准是TestUser中的age字段，然后我们只保留排序结果中的前两个对象，然后将对象保存成一个Map，以对象的id作为key，以对象本身作为value。

List testUserList = new ArrayList<>();

TestUser testUserOne = TestUser.builder().id(1).age(10.0).name("one").build();

testUserList.add(testUserOne);

TestUser testUserTwo = TestUser.builder().id(2).age(20.0).name("two").build();

testUserList.add(testUserTwo);

testUserList.add(testUserTwo);

TestUser testUserThree = TestUser.builder().id(3).age(15.0).name("three").build();

testUserList.add(testUserThree);

System.out.println(testUserList.stream().sorted(Comparator.comparing(TestUser::getAge)).limit(4).collect(Collectors.toMap(TestUser::getId, TestUser -> TestUser)));

如果将代码改成如上所示，你就会发现其实上面的代码是存在缺陷的，该处的缺陷就是当List中存在两个相同的对象的时候，程序不知道该如何来选择，我们对上面的代码做如下的修改，这个问题就迎刃而解啦：

List testUserList = new ArrayList<>();

TestUser testUserOne = TestUser.builder().id(1).age(10.0).name("one").build();

testUserList.add(testUserOne);

TestUser testUserTwo = TestUser.builder().id(2).age(20.0).name("two").build();

testUserList.add(testUserTwo);

testUserList.add(testUserTwo);

TestUser testUserThree = TestUser.builder().id(3).age(15.0).name("three").build();

testUserList.add(testUserThree);

System.out.println(testUserList.stream().sorted(Comparator.comparing(TestUser::getAge)).limit(4).collect(Collectors.toMap(TestUser::getId, TestUser -> TestUser, (v1, v2) -> v1 )));

出现上述问题的主要原因是由于在map中已经存在了相同的key，该方法无法确定要保留哪一个value，通过 （v1, v2） -> v1 的方法就可以确定是保留原来的对象，如果要保留新put的对象的话，就用（v1, v2） -> v2。

通过上面的介绍，我们知道了Stream中的sorted()和limit()的简单的用法，希望可以对你有用。

最后，

将上面实例中的TestUser对象贴出来

@Data

@AllArgsConstructor

@Builder

@NoArgsConstructor

public class TestUser {

private Integer id;

private String name;

private Double age;

private String remark;

private Long code;

}

对List集合中的对象进行按某个属性排序

最近在实际的开发工作中，碰到排序的问题，如题，我们如何针对List集合中的某一个属性进行排序

这里先举一个简单的例子

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

/**

* Created by IntelliJ IDEA

* 这是一个神奇的Class

*

* @author zhz

* @date 2019/9/25 10:37

*/

public class DemoTest {

public static void main(String[] args) {

List list1 = new ArrayList<>();

list1.add("3");

list1.add("4");

list1.add("1");

list1.add("2");

list1.add("f");

list1.add("a");

System.out.println("排序前--:"+list1.toString());

Collections.sort(list1);

System.out.println("排序前后--:"+list1.toString());

}

}

打印结果如下：

可以总结为，加单的String类型的排序，是排数字，再排字母，默认排序方式是升序。

下面言归正传，要是一个List中存的是某种对象，该对象有多种属性，那么如何进行升序或者降序排序呢？

这个时候我们就会进行一系列猛如虎的操作，结果有可能会遇到下面这种坑：

这时候你可能会问那我们怎么搞啊：

下面首先我们先创建一个测试用类，这里重点说一哈，可以实现一个Comparable接口重写compareTo

/**

* Created by IntelliJ IDEA

* 这是一个神奇的Class

*

* @author zhz

* @date 2019/9/25 10:49

*/

public class TestA implements Comparable {

private String name;

private Integer age;

public TestA(String name, Integer age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

@Override

public String toString() {

return "TestA [name=" + name + ", age=" + age + "]";

}

@Override

public int compareTo(TestA o) {

return this.age.compareTo(o.getAge());

}

}

我们就可以进行下一步的检验结果的操作了

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

/**

* Created by IntelliJ IDEA

* 这是一个神奇的Class

*

* @author zhz

* @date 2019/9/25 10:37

*/

public class DemoTest {

public static void main(String[] args) {

TestA testA1 = new TestA("老张", 3);

TestA testA2 = new TestA("老李", 1);

TestA testA3 = new TestA("老王", 2);

List list = new ArrayList<>();

list.add(testA1);

list.add(testA2);

list.add(testA3);

System.out.println("排序前--:"+list.toString());

Collections.sort(list, new Comparator() {

@Override

public int compare(TestA o1, TestA o2) {

//升序

return o1.getAge().compareTo(o2.getAge());

}

});

System.out.println("升序排序后--:"+list.toString());

Collections.sort(list, new Comparator() {

@Override

public int compare(TestA o1, TestA o2) {

//降序

return o2.getAge().compareTo(o1.getAge());

}

});

System.out.println("降序排序后--:"+list.toString());

}

}

输出的是啥：

附：本文大部分参考网上资源,主要用于个人的笔记心得记录

下面是个人在处理业务中的使用：

到了这里你觉得很神奇？错了，现在是java8的时代，我们来看看新特性下如何排序的：

List all = new ArrayList<>();

//根据创建时间降序排序

all.sort(Comparator.comparing(CountCardDetailVo::getCreateTime).reversed());

//根据创建时间升序排序

all.sort(Comparator.comparing(CountCardDetailVo::getCreateTime));

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。