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

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

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

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

(0)

相关推荐

  • 根据list中对象的属性去重和排序小结(必看篇)

    如下所示: //去重 public class User { private int id; private String name; private int age; public User(){} public User(int id, String name, int age) { super(); this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void

  • java根据List内对象的属性排序方法

    方法一:实现Comparator接口,并重写compare方法 实体类代码: import java.util.Comparator; /** * 学生类 方法一 * 实现Comparator接口 * 并重写compare方法 * @author liaot * */ public class Student implements Comparator<Student>{ private String name; //姓名 private int age; //年龄 //重写 比较方法 本次例

  • java list集合排序按某一属性排序操作

    我就废话不多说了,大家还是直接看代码吧~ public List<FreightM> sortList(List<FreightM> list){ Collections.sort(list, new Comparator<FreightM>(){ @Override public int compare(FreightM o1, FreightM o2) { if(o1.getType()==0){ return -1; }else{ return 1; } } })

  • java ArrayList集合中的某个对象属性进行排序的实现代码

    开发中有时候需要自己封装分页排序时,List如何对某一属性排序呢,分享一个小实例,大家共勉,希望能对大家有用,请多多指教. 1.Student的Bean如下: public class Student { private int age; private String name; private String weight; public String getWeight() { return weight; } public void setWeight(String weight) { th

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

    目录 list stream:对List中的对象先进行排序再获取前n个对象 接下来我们就来看一下这个方法 通过自定义一个的对象比较方法来进行排序 将上面实例中的TestUser对象贴出来 对List集合中的对象进行按某个属性排序 这里先举一个简单的例子 list stream:对List中的对象先进行排序再获取前n个对象 开发中我们经常会对一个List中的对象进行排序,使用排序后的结果来进行计算或使用,今天来介绍一个非常简洁的对List中对象进行排序,排序后的结果我们只获取前N个对象 接下来我们

  • Java8使用stream实现list中对象属性的合并(去重并求和)

    前言 需要对一个List中的对象进行唯一值属性去重,属性求和,对象假设为BillsNums,有id.nums.sums三个属性,其中id表示唯一值,需要nums与sums进行求和,并最后保持一份. 例如说:("s1", 1, 1),("s1",2,3),("s2",4,4), 求和并去重的话,就是("s1", 3, 4),("s2",4,4) 对象与属性 class BillsNums { private

  • List集合对象中按照不同属性大小排序的实例

    实例如下: package com.huad.luck; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class Test { public static void main(String[] args) { Person p = new Person(); p.setName("tom"); p.

  • 将ResultSet中得到的一行或多行结果集封装成对象的实例

    首先说一下这个使用场景,我们在使用jdbc连接数据库的时候,执行查询语句时候会得到一个结果集,如果想要再获取这个结果集中的值,就需要我们将他转换成一个对象,然后通过对象的get和set方法来获取到数据库中的值. public class BaseDao <E> { private Class<?> cls; public BaseDao() { //得到父类的泛型 Type sType=getClass().getGenericSuperclass(); //得到实际的类型参数数组

  • Java 如何从spring容器中获取注入的bean对象

    1.使用场景 控制层调用业务层时,控制层需要拿到业务层在spring容器中注入的对象 2.代码实现 import org.apache.struts2.ServletActionContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.suppo

  • Js 获取当前函数参数对象的实现代码

    有时候在封装控件的时候在很多 Js 函数中需要获取传入的直接参数或者对象参数,那么我们就需要每次都去判断第一个对象,所以为了方便在此封装一个函数,来获取当前函数中的参数值: /*------------------------------------------ * 清除字符串两端空格,包含换行符.制表符 *------------------------------------------*/ String.prototype.Trim = function () { return this.

  • Java中集合和数组的排序方式小结

    根据约定,在使用java编程的时候应尽可能的使用现有的类库,当然你也可以自己编写一个排序的方法,或者框架,但是有几个人能写得比JDK里的还要好呢?使用现有的类的另一个好处是代码易于阅读和维护,这篇文章主要讲的是如何使用现有的类库对数组和各种Collection容器进行排序,(文章中的一 部分例子来自<Java Developers Almanac 1.4>) 首先要知道两个类:java.util.Arrays和java.util.Collections(注意和Collection的区 别)Co

  • Python利用operator模块实现对象的多级排序详解

    前言 最近在工作中碰到一个小的排序问题,需要按嵌套对象的多个属性来排序,于是发现了Python里的operator模块和sorted函数组合可以实现这个功能.本文介绍了Python用operator模块实现对象的多级排序的相关内容,分享出来供大家参考学习,下面来看看详细的介绍: 比如我有如下的类关系,A对象引用了一个B对象, class A(object): def __init__(self, b): self.b = b def __str__(self): return "[%s, %s,

  • JavaScript对象数组的排序处理方法

    本文实例讲述了JavaScript对象数组的排序处理方法.分享给大家供大家参考,具体如下: javascript的数组排序函数 sort方法,默认是按照ASCII 字符顺序进行升序排列. arrayobj.sort(sortfunction); 参数:sortFunction 可选项.是用来确定元素顺序的函数的名称.如果这个参数被省略,那么元素将按照 ASCII 字符顺序进行升序排列. sort 方法将 Array 对象进行适当的排序:在执行过程中并不会创建新的 Array 对象. 如果为 so

  • 浅谈jQuery this和$(this)的区别及获取$(this)子元素对象的方法

    1.JQuery this和$(this)的区别 相信很多刚接触JQuery的人,很多都会对$(this)和this的区别模糊不清,那么这两者有什么区别呢? 首先来看看JQuery中的  $()  这个符号,实际上这个符号在JQuery中相当于JQuery(),即$(this)=jquery();也就是说,这样可以返回一个jquery对象.那么,当你在网页中alert($('#id'));时,会弹出一个[object Object ],这个object对象,也就是jquery对象了. 那么,我们

随机推荐