逸学java【初级菜鸟篇】9.3 Stream流

hi，我是逸尘，一起学java吧

---

得益于Lambda所带来的函数式编程，引入了一个全新的Stream流概念（就是都基本使用lambda的形式）。

流处理

我们首先理解什么是流处理，它类似于sql语句，可以执行非常复杂的过滤，映射，查找，收集等功能，且代码很少，但是可读性不高。字如其名，它的处理如同流淌的水一样，或者可以理解为流水线一样。

Stream流

Stream流也是流处理的一种，大多数流处理都是在Stream接口处理的，它是一个泛接口，所以它可以操作的元素是任意对象，他的操作可以用lambda去书写（推荐）。

生成Stream流

Stream操作集合和数组的第一步是得到（生成）Stream流。

在Collection接口默认方法是stream()生成流。

 在数组中使用Arrays.stream(数组) /或Stream.of(数组);

 中间操作方法

其次我们就可以使用中间操作来处理这些元素对象。

这里举出一些常见的API

• forEach : 逐一处理(遍历)
• count：统计个数
• filter : 过滤元素 【数据过滤】
• distinct：去除重复元素 【数据过滤】
• limit : 取前几个元素 【数据过滤】
• skip : 跳过前几个 【数据过滤】
• map : 加工方法 【数据映射】
• allMatch：判断流中的元素是否会全部符合某一个条件 【数据查找】
• concat：合并流

终结操作方法

终结操作方法调用以后流就无法使用了它是流的最后一个过程。

常见的有API有

单独保存的操作方法

• collect() 方法配合collectors类将流的结果进行保存

处了stream流本身的方法我们还有两个可以协助流操作的类

Collectors类

collectors是一个收集器类，可以将Stream流对象进行封装，归集，分组，是数据的收集，筛选出特殊的数据，可以复杂的统计。

1.toList()将流元素封装到List集合 toSet() toMap()类似

2.toCollection(Supplier<C> collectionFactory) 将流中的元素收集到指定类型的集合中的方法

即一个类型为 Supplier<C> 的函数式接口，其中 C 是要创建的集合类型。例如，如果我们想要创建一个 LinkedList 集合，可以这样使用该方法： 

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(LinkedList::new));

3.groupingBy(Function<? super T, ? extends K> classifier) 

• 一个函数式接口 classifier，表示如何对流中的元素进行分类。

例如，我们有一个字符串列表，并希望按照字符串长度分组：

List<String> list = Arrays.asList("apple", "banana", "peach", "grape","pear");
Map<Integer, List<String>> map = list.stream().collect(Collectors.groupingBy(String::length));

 在上面的代码中，我们使用 String::length 函数式接口将字符串转换为它的长度，并将其作为分类键。运行结果如下：

{4=[pear], 5=[apple, peach,grape], 6=[banana]}

需要注意的是，groupingBy() 方法返回的是一个 Map 对象，其中键是分类键.

Collectors.groupingBy() 方法还提供了第二个参数 downstream，用于进一步对分组的结果进行处理。例如，我们可以使用 Collectors.counting() 方法统计每个分组中元素的数量：

Map<Integer, Long> map = list.stream()
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));

上面的代码中，我们使用 Collectors.counting() 方法作为 downstream 参数，统计了每个分组中元素的数量，并将结果封装为 Long 类型。运行结果如下：

{4=1, 5=3, 6=1}

4.toConcurrentMap

将流中的元素收集到一个并发 Map 中的方法

ConcurrentMap<Integer, String> concurrentMap = Stream.of("a", "b", "c")
    .collect(Collectors.toConcurrentMap(
        String::length,
        Function.identity()
    ));

在上面的例子中，我们使用 toConcurrentMap() 方法创建了一个并发 Map，它将字符串的长度作为键，字符串本身作为值。具体来说，这个方法接受两个参数：

一个函数式接口 keyMapper，表示如何将流中的元素转换成键；
一个函数式接口 valueMapper，表示如何将流中的元素转换成值。
对于上述例子中的流，String::length 函数式接口将字符串转换成它的长度，而 Function.identity() 函数式接口则将字符串映射成它本身。因此得到的结果为：

{1=a, 2=b, 3=c}

 5.以及averagingDouble计算元素平均值，maxBy返回符合条件的最大值，joining()按顺序将元素连接成一个String类型数据，counting()统计个数等等

optional类

这是一个容器类

它的主要功能是针对NullpointerException空指针异常做处理，可以保证保存的值不为null。

of()返回一个value值等于参数的optional实例

ofNullable()是返回一个value值等于非null参数的optional实例

filter()是给定条件值匹配

empty()是静态方法，返回一个空值的optional实例

案例 

我们上面的中间操作，其实是对我们的数据源进行加工。

这里我们简单做了一个去重        

package com.yd.yc;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Thirteen {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(6,88,4,5,22,22,6,66,7);
        //原数据
        printeach(list);
        //获取stream，去重，收集器类重新封装
        List<Integer> collect = list.stream().distinct().collect(Collectors.toList());
        printeach(collect);
    }
        //遍历方法
    private static void printeach(List<Integer> list) {
        System.out.println("集合内容"+list);
        //逐一处理(遍历)里面是lambda
        list.stream().forEach(n-> System.out.println(n+""));

    }
}

某个公司的部门，分为开财务部门和开发部门，现在需要进行月中数据结算。

创建一张员工

部门	姓名	年龄	月工资	性别
开发部	张三	28	15000	男
开发部	李四	35	20000	女
开发部	王五	29	18000	男
财务部	赵六	33	16000	女
财务部	刘七	30	17000	男
财务部	陈八	27	14000	女

对应的是我们的员工实体类

public class Employee {  
    private String name;  
    private int age;  
    private double monthlySalary;  
    private String gender;  
    private String department;  
  
    public Employee(String name, int age, double monthlySalary, String gender, String department) {  
        this.name = name;  
        this.age = age;  
        this.monthlySalary = monthlySalary;  
        this.gender = gender;  
        this.department = department;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public double getMonthlySalary() {  
        return monthlySalary;  
    }  
  
    public String getGender() {  
        return gender;  
    }  
  
    public String getDepartment() {  
        return department;  
    }  
}

分别筛选出2个部门的最高工资的员工信息，封装成优秀员工对象topperformer

方案A

package com.yd.yc;

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

public class EmployeeTest {
    public static void main(String[] args) {
        Employee employee1 = new Employee("张三", 28, 15000, "男", "开发部");
        Employee employee2 = new Employee("李四", 35, 20000, "女", "开发部");
        Employee employee3 = new Employee("王五", 29, 18000, "男", "开发部");
        Employee employee4 = new Employee("赵六", 33, 16000, "女", "财务部");
        Employee employee5 = new Employee("刘七", 30, 17000, "男", "财务部");
        Employee employee6 = new Employee("陈八", 27, 44000, "女", "财务部");
        //测试
        //System.out.println(employee1.getName());  // 输出：张三
        //System.out.println(employee2.getMonthlySalary());  // 输出：20000.0
        ArrayList<Employee> employeeList = new ArrayList<>();
        employeeList.add(employee1);
        employeeList.add(employee2);
        employeeList.add(employee3);
        employeeList.add(employee4);
        employeeList.add(employee5);
        employeeList.add(employee6);

        //A方案
        //filter是过滤找到符合条件的元素
        //Collectors.maxBy去返回符合条件的最大值,Comparator.comparing(param),param : 这个参数是Function函数式对象,默认大，Comparator.reverseOrder()默认倒序
        Optional<Employee> result = employeeList.stream()
                .filter(e -> "开发部".equals(e.getDepartment()))
                .collect(Collectors.maxBy(Comparator.comparing(Employee::getMonthlySalary)));
        //返回一个实体类对象
        Employee employee = result.get();
        System.out.println(employee.getName());

        //第二种写法
        Employee  resultOne= employeeList.stream().filter(e -> "财务部".equals(e.getDepartment()))
                .max((o1, o2) -> Double.compare(o1.getMonthlySalary(), o2.getMonthlySalary())).get();
        //必须重写toString才可以有内容
        System.out.println(resultOne);
        System.out.println(resultOne.getMonthlySalary());
        //包装在一个优秀员工里
        List<Employee> topEmployees = new ArrayList<>();
        topEmployees.add(resultOne);
        topEmployees.add(employee);
        System.out.println(topEmployees);
        
    }
}

 方案B

        //B方案
        Map<String, List<Employee>> groupedByDepartment = employeeList.stream()
                //分组
                .collect(Collectors.groupingBy(Employee::getDepartment));


        List<Employee> topEmployees = new ArrayList<>();

        for (List<Employee> departmentEmployees : groupedByDepartment.values()) {
            Employee topEmployee = departmentEmployees.stream()
                    .max(Comparator.comparingDouble(Employee::getMonthlySalary))
                    //注意，如果一个部门没有员工，那么这个方法将返回null
                    //该方法在给定的流中找不到元素时返回一个默认值。
                    .orElse(null);
            if (topEmployee != null) {
                topEmployees.add(topEmployee);
            }
        }
        System.out.println(topEmployees);

我们要注意的是stream流是方便操作集合/数组的手段，集合/数组才是开发中的目的。