Java8新特性：归约与收集

归约： reduce（T identity，BinaryOperator）/reduce(BinaryOperator) 可以将流中元素反复结合起来，得到一个值

identity 起始值

BinaryOperator  二元运算 

package entity;

public class Employee {
    private String name;
    private int age;
    private double money;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public Employee() {
    }

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



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

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

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

package com;

import entity.Employee;

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

public class Main {


    static List employees = Arrays.asList(
            new Employee("aa", 18, 1),
            new Employee("bb", 22, 2),
            new Employee("cc", 33, 3),
            new Employee("dd", 11, 4),
            new Employee("ee", 23, 5),
            new Employee("ff", 68, 6)
    );


    public static void main(String[] args) {
        Double reduce = employees.stream()
                .map((e) -> e.getMoney())
                .reduce((double) 0, (x, y) -> x + y);
        System.out.println("reduce = " + reduce);


    }
}

public static void main(String[] args) {
    Double reduce = employees.stream()
            .map((e) -> e.getMoney())
            .reduce((double) 0, (x, y) -> x + y);
    System.out.println("reduce = " + reduce);


    Optional reduce1 = employees.stream().map((e) -> e.getMoney())
            .reduce((x, y) -> Double.sum(x, y));
    System.out.println("reduce1 = " + reduce1.get());

}

下面的那个返回到是 Optional，为了避免空指针异常来的，然后那个第二个的话，只有一个参数，没有 初始值，所以可能出现空指针异常。

==============================================

============================================

收集

collect：将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中的元素做汇总

package com;

import entity.Employee;

import java.util.*;
import java.util.stream.Collectors;

public class Main {


    static List employees = Arrays.asList(
            new Employee("aa", 18, 1),
            new Employee("bb", 22, 2),
            new Employee("cc", 33, 3),
            new Employee("dd", 11, 4),
            new Employee("ee", 23, 5),
            new Employee("ff", 68, 6)
    );


    public static void main(String[] args) {
        String collect = employees.stream()
                .map((e) -> e.getName())
                .collect(Collectors.joining());
        System.out.println("collect = " + collect);

        System.out.println("==========");

        List list = employees.stream()
                .map((e) -> e.getName())
                .collect(Collectors.toList());
//        for (String l:list){
//            System.out.println(l);
//        }
        list.forEach((x)-> System.out.print(x));

        System.out.println("==========");

        Set collect1 = employees.stream().map((x) -> x.getName())
                .collect(Collectors.toSet());
        collect1.forEach((x)-> System.out.print(x));

        System.out.println("==========");

        HashSet collect2 = employees.stream().map((x) -> x.getName())
                .collect(Collectors.toCollection(HashSet::new));
        collect2.forEach((x)-> System.out.print(x));

        System.out.println("==========");
        Double average = employees.stream()
                .collect(Collectors.averagingDouble((x) -> x.getMoney()));
        System.out.println("average = " + average);

        System.out.println("==========");
        Long count = employees.stream()
                .collect(Collectors.counting());
        System.out.println("count = " + count);

        System.out.println("==============");
        Double collect3 = employees.stream()
                .collect(Collectors.summingDouble((x) -> x.getMoney()));
        System.out.println("collect3 工资总和= " + collect3);

        System.out.println("=============");
        Optional employee = employees.stream()
                .collect(Collectors.maxBy((x, y) -> Double.compare(x.getMoney(), y.getMoney())));
        System.out.println("employee.get() = " + employee.get());

    }
}

z