亲宝软件园·资讯

展开

List对象排序再获取前n个对象

有梦想的攻城狮 人气:4

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

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

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

List<Integer> 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<TestUser> 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<TestUser> 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<TestUser> 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<String> 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<TestA> {
    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<TestA> list  = new ArrayList<>();
        list.add(testA1);
        list.add(testA2);
        list.add(testA3);
        System.out.println("排序前--:"+list.toString());
        Collections.sort(list, new Comparator<TestA>() {
            @Override
            public int compare(TestA o1, TestA o2) {
                //升序
                return o1.getAge().compareTo(o2.getAge());
            }
        });
        System.out.println("升序排序后--:"+list.toString());
        Collections.sort(list, new Comparator<TestA>() {
            @Override
            public int compare(TestA o1, TestA o2) {
                //降序
                return o2.getAge().compareTo(o1.getAge());
            }
        });
        System.out.println("降序排序后--:"+list.toString());
    }
}

输出的是啥:

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

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

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

List<CountCardDetailVo> all = new ArrayList<>();
//根据创建时间降序排序
all.sort(Comparator.comparing(CountCardDetailVo::getCreateTime).reversed());
//根据创建时间升序排序
all.sort(Comparator.comparing(CountCardDetailVo::getCreateTime));

以上为个人经验,希望能给大家一个参考,也希望大家多多支持。

加载全部内容

相关教程
猜你喜欢
用户评论