Stream中间操作之排序 [Java][详解]

最新推荐文章于 2024-08-08 00:19:29 发布
最新推荐文章于 2024-08-08 00:19:29 发布
阅读量757 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57001006/article/details/122098609
版权

Stream中间操作之排序

  1. sorted()

    • 根据Stream流中的元素所在类重写的compareTo()方法进行自然排序
    • 流中元素的所在类必须要实现Comparable接口

这里我们先举一个例子

eg:

package stream流.中间操作.排序;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Demo1 {
    public static void main(String[] args) {
        List<Integer> arrayList = Arrays.asList(12,343,434,43);
        arrayList.stream().sorted().forEach(System.out :: println);
    }
}

这里我们再举一个例子

这个例子中涉及到了两个自定义类,这里先将这两个自定义类给出:

  1. Employee类
package stream流.中间操作;

import java.util.Objects;

public class Employee implements Comparable<Employee>{
    private int bianHao;
    private String name;
    private int age;
    private double salary;

    public Employee(){

    }
    public Employee(int bianHao, String name, int age, double salary){
        this.bianHao = bianHao;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public int getBianHao() {
        return bianHao;
    }

    public void setBianHao(int bianHao) {
        this.bianHao = bianHao;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
    @Override
    public int compareTo(Employee e){
        int value = this.getAge() - e.getAge();
        if(value == 0){
            return Double.compare(this.getSalary(),e.getSalary());
        }
        return value;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "bianHao=" + bianHao +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return bianHao == employee.bianHao &&
                age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(bianHao, name, age, salary);
    }
}
  • 这个Employee类中我们实现了Comparable接口,并且重写了compareTo()方法
    • 并且我们重写的compareTo()方法是根据多级排序的方式进行重写的
      • 这里我们先进行了年龄上的比较,然后又进行了工资上的比较(也就是年龄如果不同就根据年龄进行排序,如果年龄想等,这时候我们就根据员工的工资进行排序)
  1. EmployeeDate类
package stream流.中间操作;

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

public class EmployeeDate {
    public EmployeeDate(){

    }
    public static List<Employee> getEmployeeDate(){
        List<Employee>  list = new ArrayList<>();
        Employee e1 = new Employee(1001,"马化腾",20,8001);
        Employee e2 = new Employee(1002,"马云",47,8701);
        Employee e3 = new Employee(1003,"刘强东",34,8401);
        Employee e4 = new Employee(1004,"曹操",32,4501);
        Employee e5 = new Employee(1005,"刘备",12,5401);
        Employee e6 = new Employee(1006,"张飞",21,6601);

        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        return list;
    }
}

这个例子中的集合中的元素的模板类是我们的用户自定义类,这个时候我们要去自己实现Comparable接口

package stream流.中间操作.排序;

import stream流.中间操作.Employee;
import stream流.中间操作.EmployeeDate;

import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        List<Employee> list = EmployeeDate.getEmployeeDate();
        list.stream().sorted().forEach(System.out :: println);
    }
}

  1. sorted(Comparator c);

  • 根据我们传入的参数的排序方式进行排序(也就是定制排序)
  • 这个根据我们的Stream流中的元素所在类中就可以不用重写Comparable接口

这个时候我们举一个例子:

这个时候也涉及到两个自定义类:

  1. Employee类
package stream流.中间操作;

import java.util.Objects;

public class Employee{
    private int bianHao;
    private String name;
    private int age;
    private double salary;

    public Employee(){

    }
    public Employee(int bianHao, String name, int age, double salary){
        this.bianHao = bianHao;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public int getBianHao() {
        return bianHao;
    }

    public void setBianHao(int bianHao) {
        this.bianHao = bianHao;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "bianHao=" + bianHao +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return bianHao == employee.bianHao &&
                age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(bianHao, name, age, salary);
    }
}
  1. EmployeeDate类
package stream流.中间操作;

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

public class EmployeeDate {
    public EmployeeDate(){

    }
    public static List<Employee> getEmployeeDate(){
        List<Employee>  list = new ArrayList<>();
        Employee e1 = new Employee(1001,"马化腾",20,8001);
        Employee e2 = new Employee(1002,"马云",47,8701);
        Employee e3 = new Employee(1003,"刘强东",34,8401);
        Employee e4 = new Employee(1004,"曹操",32,4501);
        Employee e5 = new Employee(1005,"刘备",12,5401);
        Employee e6 = new Employee(1006,"张飞",21,6601);

        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        return list;
    }
}

这个例子中我们使用sorted(Comparator c)方法,进行定制排序

package stream流.中间操作.排序;

import stream流.中间操作.Employee;
import stream流.中间操作.EmployeeDate;
import java.util.stream.Stream;

import java.util.List;

public class Demo3 {
    public static void main(String[] args) {
        List<Employee> list = EmployeeDate.getEmployeeDate();
        Stream<Employee> stream = list.stream().sorted((e1,e2)->{
            int value = Integer.compare(e1.getAge(),e2.getAge());
            if(value == 0){
                return Double.compare(e1.getSalary(),e2.getSalary());
            }
            return value;
        });
        stream.forEach(System.out :: println);
    }
}
  • 这个时候我们可以发现这例子中的Employee类中并没有实现Comparable接口,这个时候也可以进行排序,这个时候我们是通过参数中的Comparator的排序方式进行排序
96岁对抗java
关注
专栏目录
Java8 Stream源码精讲：中间操作原理详解
JavaShark的博客
05-26 466
通过分析创建Stream的过程，详细介绍了Spliterator接口定义，Spliterator子类的实现细节，Spliterator在Stream中的调用时机，以及代表源阶段Stream的Head类结构。本章将继续带着大家深入理解什么是Stream中间操作，进入每一个中间操作的源码了解我们定义的lambda表达式是如何在流上处理数据的。 中间操作 Stream是惰性流，中间操作只是将lambda表达式记录下来，返回一个新的Stream，只有终止操作被调用时，才会触发计算。这样可以保证数据被尽量少的遍历
JAVA-Stream流详解
分享，学习，专注，努力，向上。
07-02 3345
Stream（流）是Java 8引入的新特性，它是一种处理集合数据的高级抽象概念。Stream流提供了一种更为简洁、强大和易于使用的方式来操作数据集合，可以进行过滤、映射、排序、聚合等各种操作，同时还支持并行处理，提高了代码的可读性和性能。
java8stream中间操作_了解一下，Java8 Stream的中间操作顺序
weixin_29088655的博客
03-02 882
介绍了Stream的中间操作顺序，对性能的影响，以及如何调优。上篇文章讲了Stream的常用方法，可以先回顾一下：图解Java8 Stream，真香垂直执行：map和filter先看下面一个例子，找出流中"b"的字符串，并将其转化为大写，包含两个中间操作 map 和 filter 以及结束操作forEach。Stream.of("a", "b", "c", "d", "e").map(str -&...
stream流中的排序
weixin_61503139的博客
01-05 659
/迭代器中遇到Arrays.asList转换的lsit必须要,新定义一个list把所有元素addAll进去,不然报错。//先按照一个字段排序,在按照另一个字段排序。
Java stream流支持多字段排序
最新发布
码海拾贝
08-08 412
对于排序而言,比较常见的场景是前端传递所需的排序字段名和排序方向,然后通过stream流或者数据库来实现排序.为动态接收参数,继承Map来支持多字段传入.另外stream流原生的sorted写起来相对比较繁琐,通过compartor方法封装构建多字段排序的逻辑.具体就是通过反射拿到对应字段的值,然后利用Compartor的comparing和thenComparing完成多字段排序.
java8-stream流的sorted 排序
li646495946的博客
05-12 2484
java8-stream流的sorted 排序介绍 介绍 排序一般按照某个字段进行进行升序或者降序排，我们自己实现排序一般会用冒泡，快排序，二分法等 如果用sorted排序，以前上百行的代码现在只需要几行代码搞定，增强的代码的简洁性 升序 List<Integer> list = Arrays.asList(10，6， 39 14); List<Integer> filter1 = list.stream() .sorted(Comparator.comparing(In
java8 stream().forEach、stream().map、stream().filter、stream().sorted的区别和用法
trusause的博客
01-15 4322
List<Teacher> list = new ArrayList<>(); list.add(Teacher.builder().age(28).name("李四").build()); list.add(Teacher.builder().age(27).name("张三").build()); list.add(Te...
Java8 stream流多字段排序
kevin_g的博客
09-14 665
List按一个类属性排序 List<类> list; 代表某集合 1 返回 对象集合以类属性升序排序 List<Object> objecList = list.stream().sorted(Comparator.comparing(类::属性)).collect(Collectors.toList())); 2 返回 对象集合以类属性降序排序 注意两种写法 //先以属性一升序,结果进行属性一降序 list.stream().sorted(Comparator.comparing
Java-Stream流详解.pptx.pptx
12-19
- **终止操作的概念**：Stream在执行完一系列中间操作后，必须有一个终端操作来结束这个操作链，例如收集结果或进行某种形式的输出。 - **终止操作的类型**：包括短路操作（如`anyMatch()`, `findFirst()`)和非短路...
常用Java排序算法详解
12-26
一、选择排序(SelectSort) 基本原理：对于给定的一组记录，经过第一轮比较后得到最小的记录，然后将该记录与第一个记录的位置进行交换；接着对不包括第一个记录以外的其他记录进行第二次比较，得到最小的记录并与第...
7大排序算法详解文档及java代码实现（可直接运行）
05-23
冒泡排序是最基础的排序算法之一，通过不断交换相邻的逆序元素来逐步完成排序。其主要步骤包括多轮比较和交换，每轮将最大（或最小）的元素“冒泡”到序列的末尾。Java实现如下： ```java void bubbleSort(int[] ...
java8的stream流编程的sorted排序方法
djw_0926的博客
03-15 383
list.stream().filter(categoryEntity -> categoryEntity.getParentCid()==0).map((menu)->{ menu.setChildren(getChildren(menu,list)); return menu; }).sorted((menu1,menu2)->{ //sorted 方法中，我们重写compare方法：如果retur
java compareto重写_String类中自动重写compareTo( )方法对汉字的比较
weixin_29096377的博客
02-16 684
在看Java从入门到精通的过程中遇到这样一道习题：定义Student类，该类不实现Comparable接口，定义一个Comparator类比较两个Student对象所在班级名称和名字，班级名相同时用名字进行排序，使用TreeSet观察排序结果。这是我最初写的程序和运行结果截图package javautil;import java.util.Iterator;import java.util.Tr...
list.stream().sorted常用之关于对象属性排序aa.compareTo(bb)
Seven71111的博客
03-25 2430
基础知识记录： Integer类型比较： Integer aa=1; Integer bb=3; System.out.println("integer的比较"); System.out.println(aa+ ".compareTo("+ bb +"): "+ aa.compareTo(bb)); aa=3; System.out.println(aa+ ".compareTo("...
Stream流中间操作——数据升序用Comparing实现与compareTo实现
落雨心星
08-19 5315
package com.xqx.A04_Practice.Demo04; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.Comparator; import java.util.function.Function; import java....
Java中有关stream()的排序、compareTo()用法
qq_40963569的博客
03-27 794
Java中有关stream()的排序、compareTo()用法
Java stream comparator 按照指定字段自定义排序
wxairn的博客
09-21 467
备注：如果其他状态也需要排序可根据实际情况修改对应的if else，升序还是降序可根据o1和o2或者使用reversed()进行调整。
Java 8 Stream的详细语法介绍
luckykapok918的专栏
05-20 1011
一、概述 Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出
关于java8新特性 Stream流的常规用法总结
MyfishCake的博客
07-27 1485
关于java8新特性中，集合的stream流的常规用法简介，以及案例演示等
Java8 Stream API与Guava操作详解
Stream API的设计理念源自函数式编程，使得开发者可以进行更高级的序列操作，例如过滤、映射、排序等，而无需显式地使用循环。 1. Stream 1.1 为什么需要Stream 在Java 8之前，对集合的操作通常需要迭代器来遍历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值