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

2. 然后我们这里给出第二个自定义类 : 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对象重复执行中间操作了,如果重复调用,这个时候就会从出现一个运行时异常 (非法的状态异常)

2. 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);
    }

}

2. 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个,这个时候就返回一个空流