使用list stream:對(duì)List中的對(duì)象先進(jìn)行排序再獲取前n個(gè)對(duì)象

更新時(shí)間：2021年09月09日 09:22:44 作者：有夢(mèng)想的攻城獅

這篇文章主要介紹了使用list stream:對(duì)List中的對(duì)象先進(jìn)行排序再獲取前n個(gè)對(duì)象，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教

list stream:對(duì)List中的對(duì)象先進(jìn)行排序再獲取前n個(gè)對(duì)象

開發(fā)中我們經(jīng)常會(huì)對(duì)一個(gè)List中的對(duì)象進(jìn)行排序，使用排序后的結(jié)果來進(jìn)行計(jì)算或使用，今天來介紹一個(gè)非常簡(jiǎn)潔的對(duì)List中對(duì)象進(jìn)行排序，排序后的結(jié)果我們只獲取前N個(gè)對(duì)象

接下來我們就來看一下這個(gè)方法

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()));

上面是一個(gè)最簡(jiǎn)單的例子，我們將一個(gè)整數(shù)List中的每一個(gè)數(shù)通過默認(rèn)的排序方法進(jìn)行排序，排序完成后，只獲取這個(gè)結(jié)果中的前兩個(gè)數(shù)。

下面在來看一個(gè)稍微復(fù)雜一些的

通過自定義一個(gè)的對(duì)象比較方法來進(jìn)行排序

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)));

上面的這個(gè)例子是將TestUser組成的List進(jìn)行排序，我們排序的標(biāo)準(zhǔn)是TestUser中的age字段，然后我們只保留排序結(jié)果中的前兩個(gè)對(duì)象，然后將對(duì)象保存成一個(gè)Map，以對(duì)象的id作為key，以對(duì)象本身作為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)));

如果將代碼改成如上所示，你就會(huì)發(fā)現(xiàn)其實(shí)上面的代碼是存在缺陷的，該處的缺陷就是當(dāng)List中存在兩個(gè)相同的對(duì)象的時(shí)候，程序不知道該如何來選擇，我們對(duì)上面的代碼做如下的修改，這個(gè)問題就迎刃而解啦：

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 )));

出現(xiàn)上述問題的主要原因是由于在map中已經(jīng)存在了相同的key，該方法無法確定要保留哪一個(gè)value，通過（v1, v2） -> v1 的方法就可以確定是保留原來的對(duì)象，如果要保留新put的對(duì)象的話，就用（v1, v2） -> v2。

通過上面的介紹，我們知道了Stream中的sorted()和limit()的簡(jiǎn)單的用法，希望可以對(duì)你有用。

最后，

將上面實(shí)例中的TestUser對(duì)象貼出來

@Data
@AllArgsConstructor
@Builder
@NoArgsConstructor
public class TestUser {
    private Integer id;
    private String name;
    private Double age;
    private String remark;
    private Long code;
}

對(duì)List集合中的對(duì)象進(jìn)行按某個(gè)屬性排序

最近在實(shí)際的開發(fā)工作中，碰到排序的問題，如題，我們?nèi)绾吾槍?duì)List集合中的某一個(gè)屬性進(jìn)行排序

這里先舉一個(gè)簡(jiǎn)單的例子

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
 * Created by IntelliJ IDEA
 * 這是一個(gè)神奇的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());
    }
}

打印結(jié)果如下：

可以總結(jié)為，加單的String類型的排序，是排數(shù)字，再排字母，默認(rèn)排序方式是升序。

下面言歸正傳，要是一個(gè)List中存的是某種對(duì)象，該對(duì)象有多種屬性，那么如何進(jìn)行升序或者降序排序呢？

這個(gè)時(shí)候我們就會(huì)進(jìn)行一系列猛如虎的操作，結(jié)果有可能會(huì)遇到下面這種坑：

這時(shí)候你可能會(huì)問那我們?cè)趺锤惆。?/p>

下面首先我們先創(chuàng)建一個(gè)測(cè)試用類，這里重點(diǎn)說一哈，可以實(shí)現(xiàn)一個(gè)Comparable接口重寫compareTo

/**
 * Created by IntelliJ IDEA
 * 這是一個(gè)神奇的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());
    }    
}

我們就可以進(jìn)行下一步的檢驗(yàn)結(jié)果的操作了

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
 * Created by IntelliJ IDEA
 * 這是一個(gè)神奇的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());
    }
}

輸出的是啥：

附：本文大部分參考網(wǎng)上資源,主要用于個(gè)人的筆記心得記錄

下面是個(gè)人在處理業(yè)務(wù)中的使用：

到了這里你覺得很神奇？錯(cuò)了，現(xiàn)在是java8的時(shí)代，我們來看看新特性下如何排序的：

List<CountCardDetailVo> all = new ArrayList<>();
//根據(jù)創(chuàng)建時(shí)間降序排序
all.sort(Comparator.comparing(CountCardDetailVo::getCreateTime).reversed());
//根據(jù)創(chuàng)建時(shí)間升序排序
all.sort(Comparator.comparing(CountCardDetailVo::getCreateTime));