久久福利国产,欧美区在线播放,欧美日韩乱国产

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

打印結果如下：

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

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

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

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

使用list stream:對List中的對象先進行排序再獲取前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());
  }    
}

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

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

輸出的是啥：

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

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

下面是個人在處理業務中的使用：

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

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

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

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