使用list stream:對List中的對象先進行排序再獲取前n個對象

更新時間：2021年09月09日 09:22:44 作者：有夢想的攻城獅

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

list stream:對List中的對象先進行排序再獲取前n個對象

開發(fā)中我們經(jīng)常會對一個List中的對象進行排序，使用排序后的結(jié)果來進行計算或使用，今天來介紹一個非常簡潔的對List中對象進行排序，排序后的結(jié)果我們只獲取前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()));

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

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

通過自定義一個的對象比較方法來進行排序

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進行排序，我們排序的標(biāo)準(zhǔn)是TestUser中的age字段，然后我們只保留排序結(jié)果中的前兩個對象，然后將對象保存成一個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)));

如果將代碼改成如上所示，你就會發(fā)現(xiàn)其實上面的代碼是存在缺陷的，該處的缺陷就是當(dāng)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 )));

出現(xiàn)上述問題的主要原因是由于在map中已經(jīng)存在了相同的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集合中的對象進行按某個屬性排序

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

這里先舉一個簡單的例子

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

打印結(jié)果如下：

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

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

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

這時候你可能會問那我們怎么搞?。?/p>

下面首先我們先創(chuàng)建一個測試用類，這里重點說一哈，可以實現(xiàn)一個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());
    }    
}

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

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

輸出的是啥：

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

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

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

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