Stream的终止操作 [Java]

Stream的终止操作之归约

1. T reduce(T identiey , BinaryOperation b);

   • 可以将流中元素反复结合起来,得到一个值, 返回一个T类型的数据
     • 这种反复结合就类似于递归思想
     • 这里的反复结合也就是这个方法的内部会自动进行反复的结合,比如如果这个二元函数做的是一个加法运算,那么两个参数相加之后的结果作为返回值又会放到二元函数运算的第一个参数上,然后这个参数又和后面的流中的元素相加,这样一直反复进行运算
     • 也就是一直在重复调用 T apply(T t1,T t2);方法
       • 每次计算的结果都放到 t1 位置上,然后一直重复运算直到流中的元素全部参与运算完毕
   • 这个方法中的第一个参数identity为初始值
   • 这个方法的第二个参数b为一个二元函数型接口实例

注意 : 这里的BinaryOperation< T>接口继承了BiFunction<T,T,T>接口

在大数据中我们常常会使用到先映射再归约来获取所有数据的某个属性的总和

eg: 这里我们举一个例子 : 计算 1-10之间的自然数的和

package stream流.终止操作;

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

public class Demo1 {
    public static void main(String[] args) {
        /* 
        这个时候我们先创建了一个由Integer类型元素组成的List集合
         */
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        /*
        这里我们通过reduce()方法从0开始和流中的所有元素进行了一个加法运算
        
        注意: 这里的返回值类型为Integer类型
         */
        Integer integer = list.stream().reduce(0,(e1,e2) -> {
            return e1 + e2;
        });
        System.out.println(integer);
    }
}

2. Optional< T> reduce(BinaryOperator b);

   • 可以将流中的元素反复结合起来,得到一个值,返回Optional< T>类型

注意: 这个方法和我们的前面的reduce()方法不同的地方就在于: 这个方法返回值类型为Optional< T>,而前面的方法的返回值类型是T类型

eg:这里我们举一个例子 : 计算员工工资的总和

这个例子中我们提到了两个自定义类: 我们将这两个自定义类给出:

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

这里我们给出主函数:

package stream流.终止操作;

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

import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        List<Employee> list = EmployeeDate.getEmployeeDate();
        //这里是使用lambda表达式的方式
//        Stream<Double> stream = list.stream().map(e -> e.getSalary());
        /*
        这里我们就是使用了方法引用的情况三 : 类 :: 非静态方法
         */
        Stream<Double> stream = list.stream().map(Employee :: getSalary);
        Optional<Double> optional = stream.reduce((e1,e2) ->{
            return e1 + e2;
        });
        System.out.println(optional);

    }
}

BinaryOperation< T> extends BiFunction<T,T,T>

• BinaryOperation< T>接口中的apply()方法声明的形式为:

  • T apply(T t1 , T t2);

• BiFunction<T,U,R>接口中的apply()方法声明的形式为:

  • T apply(U u , R r);