JDK1.8新特性:list使用stream排序(多字段)

JDK1.8新特性 list使用stream排序(多字段)

1.stream()方法:将集合装为流
2.collect()方法:将流转为集合
3.filter()方法:将转为流的集合过滤出满足要求的流
4.map()方法:将每个元素映射成新元素
5.limit(n):获取n个元素
6.skip(n):跳过n元素
7.skip和limit组合实现分页(对数据库的压力没有减轻,只是看着分页了)
8.distinct:去除重复元素

        //五个user对象
        User user1 = new User(1, "张三", 10);
        User user2 = new User(2, "李四", 15);
        User user3 = new User(3, "王五", 20);
        User user4 = new User(4, "赵六", 25);
        User user5 = new User(5, "严七", 30);
 
        //将User对象存入list
        List<User> userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        userList.add(user5);
 
        System.out.println(userList);
        //[User{id=1, username='张三', age=10}, User{id=2, username='李四', age=15}, User{id=3, username='王五', age=20}, User{id=4, username='赵六', age=25}, User{id=5, username='严七', age=30}]
 
        //1.stream()方法:将集合装为流
        Stream<User> stream = userList.stream();
        System.out.println(stream);
        //打印对象地址。java.util.stream.ReferencePipeline$Head@65f651eb
 
        //2.collect()方法:将流转为集合
        List<User> users = userList.stream().collect(Collectors.toList());
        System.out.println(users);
        //[User{id=1, username='张三', age=10}, User{id=2, username='李四', age=15}, User{id=3, username='王五', age=20}, User{id=4, username='赵六', age=25}, User{id=5, username='严七', age=30}]
 
        //3.filter()方法:将转为流的集合过滤出满足要求的流
        List<User> userList1 = userList.stream().//将集合转为流
                filter(user -> user.getAge() > 20).//过滤出年龄大于20的user。(类似于sql中的where user.age > 20)
                collect(Collectors.toList());//将流转回集合(便于打印观察结果)
        System.out.println(userList1);
        //[User{id=4, username='赵六', age=25}, User{id=5, username='严七', age=30}]
 
        //4.map()方法:将每个元素映射成新元素
        List<User> userList2 = userList.stream().filter(user -> user.getAge() > 20).//过滤出年龄大于20的user
                map(user -> {//将过滤得到的user对象的年龄设置为50
            user.setAge(50);//执行你想要的操作,每个元素会映射产生新元素,所以map()方法要有返回值
            return user;//返回新元素
        }).collect(Collectors.toList());//将流转为集合
        System.out.println(userList2);
        //[User{id=4, username='赵六', age=50}, User{id=5, username='严七', age=50}]
 
        //5.limit(n):获取n个元素
        //获取前三个元素。类似于mysql数据库中的  'limit 参数一,参数二' 关键字的参数二
        List<User> userList3 = userList.stream().limit(3).collect(Collectors.toList());
        System.out.println(userList3);
        //[User{id=1, username='张三', age=10}, User{id=2, username='李四', age=15}, User{id=3, username='王五', age=20}]
 
        //6.  skip(n):跳过n元素
        //跳过两个元素,类似于mysql数据库中  'limit 参数一,参数二' 关键字的参数一
        List<User> userList4 = userList.stream().skip(2).collect(Collectors.toList());
        System.out.println(userList4);
        //[User{id=3, username='王五', age=20}, User{id=4, username='赵六', age=50}, User{id=5, username='严七', age=50}]
 
        //7.skip和limit组合实现分页
        //获取第二页数据(每页显示两条数据)
        List<User> userList5 = userList.stream().skip((2-1)*2).limit(2).collect(Collectors.toList());
        System.out.println(userList5);
        //[User{id=3, username='王五', age=20}, User{id=4, username='赵六', age=50}]
 
        //8.  distinct:去除重复元素
        //向集合中插入一个重复元素
        userList.add(user5);
        System.out.println(userList);
        //[User{id=1, username='张三', age=10}, User{id=2, username='李四', age=15}, User{id=3, username='王五', age=20}, User{id=4, username='赵六', age=50}, User{id=5, username='严七', age=50}, User{id=5, username='严七', age=30}]
        //去重(实体类中需要实现equals()和hashCode())
        List<User> userList6 = userList.stream().distinct().collect(Collectors.toList());
        System.out.println(userList6);
        //[User{id=1, username='张三', age=10}, User{id=2, username='李四', age=15}, User{id=3, username='王五', age=20}, User{id=4, username='赵六', age=50}, User{id=5, username='严七', age=50}]
@Data
public class SortVO implements Serializable {
    private Integer sort5;
    private Integer sort4;
    private Integer sort3;
    private Integer sort2;
    private Integer sort1;
    private Integer sort0;
    private String fenzuKey;
    private List<AntCmpltResultStatDTO> fenzuValue;
}

倒序

        list.sort(Comparator.comparing(SortVO::getSort5,Comparator.reverseOrder())
                .thenComparing(SortVO::getSort4,Comparator.reverseOrder())
                .thenComparing(SortVO::getSort3,Comparator.reverseOrder())
                .thenComparing(SortVO::getSort2,Comparator.reverseOrder())
                .thenComparing(SortVO::getSort1,Comparator.reverseOrder())
                .thenComparing(SortVO::getSort0,Comparator.reverseOrder())
        );

倒序

        List<SortVO> collectList = list.stream().sorted(
                Comparator.comparing(SortVO::getSort5,Comparator.reverseOrder())
                        .thenComparing(SortVO::getSort4,Comparator.reverseOrder())
                        .thenComparing(SortVO::getSort3,Comparator.reverseOrder())
                        .thenComparing(SortVO::getSort2,Comparator.reverseOrder())
                        .thenComparing(SortVO::getSort1,Comparator.reverseOrder())
                        .thenComparing(SortVO::getSort0,Comparator.reverseOrder())
                ).collect(Collectors.toList());

java8新特性 list使用stream排序(多字段)

List<> list; 代表某集合
 
//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(::属性一));
 
//返回 对象集合以类属性一降序排序 注意两种写法
//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(::属性一).reversed());
 //以属性一降序
list.stream().sorted(Comparator.comparing(::属性一,Comparator.reverseOrder()));
 
//返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(::属性一).thenComparing(::属性二));
 
//返回 对象集合以类属性一降序 属性二升序 注意两种写法
 //先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(::属性一).reversed().thenComparing(::属性二));
 //先以属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(::属性一,Comparator.reverseOrder()).thenComparing(::属性二));
 
//返回 对象集合以类属性一降序 属性二降序 注意两种写法
//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(::属性一).reversed().thenComparing(::属性二,Comparator.reverseOrder()));
//先以属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(::属性一,Comparator.reverseOrder()).thenComparing(::属性二,Comparator.reverseOrder()));
 
//返回 对象集合以类属性一升序 属性二降序 注意两种写法
 //先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
list.stream().sorted(Comparator.comparing(::属性一).reversed().thenComparing(::属性二).reversed()); 
//先以属性一升序,再进行属性二降序 
list.stream().sorted(Comparator.comparing(::属性一).thenComparing(::属性二,Comparator.reverseOrder()));

Comparator.comparing(类::属性一).reversed();
Comparator.comparing(类::属性一,Comparator.reverseOrder());
两种排序是完全不一样的,一定要区分开来
1 是得到排序结果后再排序,2是直接进行排序,很多人会混淆导致理解出错,
建议使用2

  • 4
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
可以使用Java 8中的Stream API和Lambda表达式来获取List中某个字段的值,并将其组成新的List集合。你可以使用map方法来映射每个对象的字段值,然后使用collect方法将这些值收集到一个新的List中。 例如,如果你有一个List<Object>对象列表,并且你想要提取其中一个字段的值,你可以使用以下代码: List<Object> objectList = new ArrayList<>(); List<Object> newList = objectList.stream() .map(Object::getVar) .collect(Collectors.toList()); 在这个例子中,我们使用stream方法将List转换为一个流,然后使用map方法将每个对象的getVar字段值映射到一个新的流中。最后,使用collect方法将这些值收集到一个新的List中。 如果你有一个List<ShoppingCart>对象列表,并且你想要提取其中一个字段的值,比如selectByUId的goodsId,你可以使用以下代码: List<ShoppingCart> selectByUId = new ArrayList<>(); List<Integer> goodsIdList = selectByUId.stream() .map(ShoppingCart::getGoodsId) .collect(Collectors.toList()); 在这个例子中,我们使用stream方法将List转换为一个流,然后使用map方法将每个对象的getGoodsId字段值映射到一个新的流中。最后,使用collect方法将这些值收集到一个新的List中。 这样,你就可以使用Java 8的Stream API和Lambda表达式来获取List中某个字段的值,并将其组成新的List集合。 #### 引用[.reference_title] - *1* *3* [Java8 stream 提取 List 中元素的某一字段生成新的 List](https://blog.csdn.net/kjahe/article/details/126489216)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [java list获取某个字段](https://blog.csdn.net/weixin_42594427/article/details/129448097)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值