Stream的中间操作 [Java]

Stream的中间操作之筛选和切片

这里关于Stream中间操作中的筛选和切片我们要介绍四个方法

首先我们来介绍关于筛选的两个方法:

  1. filter(Predicate p)
    • 从流中排序某些元素 — 也就是对流中的元素进行筛选
    • 这个方法的参数是一个断定型接口的实例对象
这篇文章中我们会举很多的例子, 并且这些例子中都使用到了两个个自定义类,这里我们将这个自定义类给出:
  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 {
    static List<Employee>  List;
    public EmployeeDate(){
        
    }

    public static List<Employee> getEmployeeDate(){
        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 = Arrays.asList(e1,e2,e3,e4,e5,e6);
        return List;
    }
}

这里我们举一个例子: — > 通过这个测试我们来理解filter()方法的使用
eg: — > 查询员工表中薪资超过7000的员工信息
package stream.中间操作;

import java.util.List;
import java.util.stream.Stream;

public class Demo1 {

    public static void main(String[] args) {
        /*
        我们先通果EmployeeDate类中的getEmployeeDate()静态方法得到一个雇员集合
         */
        List<Employee> list = EmployeeDate.getEmployeeDate();

        /*
        通过调用List集合中的stream()方法,得到这个集合对应的Stream流对象
         */
        Stream<Employee> stream = list.stream();

        /*
        这个时候我们调用这个Stream对象的filter()方法,通过给这个方法中传入一个断定型函数式接口对象
        然后就对流中的元素进行筛选
        
        这里我们使用了lambda表达式的方式创建了这个Predicate接口对象,这个断定型接口抽象方法的具体实现中
        就是判断流中的元素的salary属性是否大于7000, 也就是找出所有的工资超过7000的雇员
        
        然后最后我们进行了最终操作将这个进行了中间操作的Stream对象打印输出
         */
        stream.filter(e -> e.getSalary()>7000).forEach(System.out :: println);
    }

}
  • 注意:

    这个时候我们使用这个Stream对象执行了终止操作之后我们就不可以再使用这个对象调用中间操作

    • 如果这个时候我们再次使用这个Stream对象调用了中间操作之后就会出现一个运行时异常 ---- 非法的状态异常(IllegalStateException)
    • 其实就是我们使用一个Stream对象调用一次终止方法之后就不可以再使用这个Stream对象重复执行中间操作了,如果重复调用,这个时候就会从出现一个运行时异常 (非法的状态异常)
  1. distinct()

    • 通过流所生成的元素的hashCode()方法和equals()方法去除重复元素
      • 最终重复的元素只保留一个
    • 这个方法是一个无参方法

这里我们举一个例子 – > 通过这个例子来理解distinct()方法的使用

eg: —> 这个时候我们给我们的集合中添加一些重复的元素(这里的重复的元素的判断依据就是根据集合中的元素的所在类的hashCode()方法和equals()方法),然后我们在通过这个集合调用stream()方法得到这个集合对应的流对象,然后我们再使用这个流对象调用这个distinct()方法对流中的重复元素进行移除

package stream.中间操作;

import java.util.List;
import java.util.stream.Stream;

public class Demo2 {

    public static void main(String[] args) {
        /*
        我们先通果EmployeeDate类中的getEmployeeDate()静态方法得到一个雇员集合
         */
        List<Employee> list = EmployeeDate.getEmployeeDate();
        /*
        这里我们在list集合中存储了四个重复的数据
         */
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));

        /*
        通过调用List集合中的stream()方法,得到这个集合对应的Stream流对象
         */
        Stream<Employee> stream = list.stream();

        /*
        这个时候我们调用了Stream类中的distinct()方法,这个时候就会根据流生成元素的所在类中的
        hashCode()方法和equals()方法去除重复元素
        
        最后调用了终止操作,进行了遍历,这个时候根据遍历结果可以发现,这个时候重复的1010, "刘强东" , 40 ,8000只剩下了一个
         */
        stream.distinct().forEach(System.out :: println);
    }

}

这里我们介绍两种切片的方法

  1. limit(int n) ;
    • 截断流(也就是将流截断), 使流生成的元素不超过给定的数量(也就是输出的元素不超过n个)
    • 这个方法的参数是一个int类型的值
    • 这个方法和skip()方法互补
这里我们举一个例子: ----- >通过这个例子来理解limit()方法的使用
eg: — > 这里我们输出我们获得的List< Employee>对象中的前三个元素
package stream.中间操作;

import java.util.List;
import java.util.stream.Stream;

public class Demo1 {

    public static void main(String[] args) {
        /*
        我们先通果EmployeeDate类中的getEmployeeDate()静态方法得到一个雇员集合
         */
        List<Employee> list = EmployeeDate.getEmployeeDate();

        /*
        通过调用List集合中的stream()方法,得到这个集合对应的Stream流对象
         */
        Stream<Employee> stream = list.stream();

        /*
        这个时候我们就是限制流生成的元素的个数不超过三个

        如果这个时候有三个或者三个以上就是生成三个
        如果这个时候没有三个就是全部输出
         */
        stream.limit(3).forEach(System.out :: println);
    }

}
  1. skip(int n);
    • 掉过n个元素生成元素 ,返回一个扔掉了前n个元素的流,若流中元素不足n个,则返回一个空流
      • 空流就是什么都没有的流
    • 这个方法的参数是一个int类型的值
    • 这个方法和limit()方法互补
这里我们举一个例子 —> 我们通过这个例子来理解skip()方法的使用

eg:

package stream.中间操作;

import java.util.List;
import java.util.stream.Stream;

public class Demo4 {

    public static void main(String[] args) {
        /*
        我们先通果EmployeeDate类中的getEmployeeDate()静态方法得到一个雇员集合
         */
        List<Employee> list = EmployeeDate.getEmployeeDate();

        /*
        通过调用List集合中的stream()方法,得到这个集合对应的Stream流对象
         */
        Stream<Employee> stream = list.stream();

        /*
        这个时候跳过了前三个元素
         */
        stream.skip(3).forEach(System.out :: println);
    }

}
  • 这里要注意的就是: 如果这个时候元素不足n个,这个时候就返回一个空流
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java StreamJava 8 中引入的一种新的数据处理方式,它可以让你以一种声明式的方式来处理数据集合。Stream API 可以极大地简化 Java 程序的编写工作,使代码更加简洁、清晰,同时也可以提高程序的性能。 下面是 Java Stream 的常用操作: 1. 创建 Stream:可以通过集合、数组、文件等方式创建 Stream。 2. 中间操作:对 Stream 进行转换、过滤等操作,但不会执行任何操作。 3. 终止操作:对 Stream 进行计算、打印等操作,会执行 Stream操作。 4. 聚合操作:对 Stream 进行聚合操作,如求和、求最大值、求平均值等。 下面是一些常用的 Stream 操作示例: 1. 创建 Stream ``` List<String> list = Arrays.asList("Java", "Python", "C++", "JavaScript"); Stream<String> stream = list.stream(); // 通过集合创建 Stream IntStream intStream = IntStream.range(0, 10); // 创建一个 IntStream ``` 2. 中间操作 ``` stream.filter(s -> s.startsWith("J")) // 过滤出以 J 开头的字符串 .map(String::toUpperCase) // 将字符串转为大写 .sorted() // 排序 .distinct() // 去重 .limit(2); // 取前两个元素 ``` 3. 终止操作 ``` stream.forEach(System.out::println); // 遍历打印 Stream 中的元素 stream.count(); // 计算 Stream 中的元素个数 stream.max(String::compareTo); // 找出 Stream 中的最大值 stream.min(String::compareTo); // 找出 Stream 中的最小值 stream.reduce((a, b) -> a + b); // 将 Stream 中的所有元素累加起来 stream.collect(Collectors.toList()); // 将 Stream 转为 List ``` 4. 聚合操作 ``` IntStream intStream = IntStream.of(1, 2, 3, 4, 5); intStream.sum(); // 求和 intStream.average(); // 求平均值 intStream.max(); // 求最大值 intStream.min(); // 求最小值 ``` 这些仅是 Java Stream 的一部分常用操作,还有很多其他的操作方式。通过使用 Stream API,可以大大简化代码的编写,提高程序的性能和可读性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值