一、概述

1、Stream出现时间：JDK8

2、作用：简化集合，数组操作的API。结合了Lambda表达式

3、Stream流的思想和使用步骤：

     （1）先得到集合或数组的Stream流（就是一根传送带）

     （2）把元素放上去

     （3）然后就利用这个Stream流简化的API 来方便的操作元素

二、体验Stream流：

 1、我们先创建一个集合对象，存入一些数据

        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三丰", "张无忌", "周志祥", "赵敏", "张强");
        System.out.println(names);

 2、先用集合的方法去遍历输出

        //1.找名称开头为张的
        List<String> zhangList = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("张")) {
                zhangList.add(name);
                System.out.println(name);
            }
        }

        //2.
        List<String> zhangThreeList = new ArrayList<>();
        for (String name : zhangList) {
            if(name.length() ==3){
                zhangThreeList.add(name);
            }
        }
        System.out.println(zhangThreeList);

3.使用Streeam流输出

   初步体会认知Stream流的方便

 names.stream().filter(s ->s.startsWith("张")).filter(s ->s.length() ==3).forEach(System.out::println);

一行代码搞定上述内容

其中用到了Stream流的特有API，在下文中我们会讲到

filter：过滤元素

二、获取（三种方法）

1、获取Stream流

     创建一条流水线，并把数据放到流水线上准备进行操作

   （1）Collection集合获取流

        Collection<String> list = new ArrayList<>();
        Stream<String> s = list.stream();

   （2）Map集合获取流

        Map<String,Integer> maps = new HashMap<>();

         键流：

Stream<String> keyStream = maps.keySet().stream();

         值流：

Stream<Integer> valuesStream = maps.values().stream();

         键值对流（拿整体）

Stream<Map.Entry<String , Integer > > keyAndValuesStream = maps.entrySet().stream();

（3）数组获取流

String[] names = {"赵敏","小昭","灭绝","周芷若"};
Stream<String> nameStream = Arrays.stream(names);
Stream<String> nameStream2= Stream.of(names);//两种写法

2、中间方法

      流水线上的操作。一次操作完毕之后，还可以继续进行其他操作

      中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程

3、终结方法

       一个Stream流只能有一个终结方法，是流水线上的最后一个操作

       调用完成后就无法继续使用了，原因是不会返回Stream了

三、常用API（中间方法）

1、先创建集合，添加元素

        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

2、简述常用API

forEach：逐一处理（遍历）

 count：统计个数 

            --long count();

 filter: 过滤元素

           --Stream<T> filter(Predicate<? super T> predicate)

 limit : 取前几个元素

skip : 跳过前几个元素

 map : 加工方法

 concat : 合并流

 distinct : 去除流中重复的元素。依赖（hashCode 和 equals方法）

代码演示：

        //Stream<T> filter(Predicate<? super T> predicate)
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);//简便方法

        System.out.println(list.stream().filter(s -> s.length() == 3).count());//要用 long size 储存

        //list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s));//两种写法
        list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);
        //在两个参数一样的情况下，才可以省略两个s  ，而打成 :: 的形式

        //Map加工方法：第一个参数原材料 -> 第二个参数是加工后的结果
        //给集合元素的前面都加上一个：黑马的：
        list.stream().map(s -> "黑马的" + s).forEach(System.out::println);

        //需求：把所有的名称 都加工成一个学生对象
        list.stream().map(s -> new Student(s)).forEach(System.out::println);
        //?下一个式子
        // list.stream().map(Student::new).forEach(System.out::println); //构造器经用   方法引用

        //合并流
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 = Stream.of("Java1","Java2");
        // public static <T> Stream<T> concat(Stream <? extends T> a,Stream<? extends T> b)
        Stream<String> s3 = Stream.concat(s1,s2);
        s3.forEach(System.out::println);
        s3.distinct().forEach(System.out::println);

四、综合运用案例

需求：

*        某个公司的开发部门，分为开发一部和二部，现在需要进行年中数据结算

* 分析：

* （1）员工信息至少包含了（名称、性别、工资、奖金、处罚记录）

* （2）开发一部有四个员工、开发二部有5名员工

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

* （4）分别统计出个部门的平均月收入，要求去掉最高和最低工资

* （5）统计2个开发部门整体的平均工资，去掉最低和最高工资的平均值 

 1.创建员工对象，做成一个类

package Stream.Test;

public class Employee {
    private String name;
    private char sex;
    private double salary;
    private double bonus;
    private String punish;//处罚方法

    public Employee() {
    }

    public Employee(String name, char sex, double salary, double bonus, String punish) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
        this.bonus = bonus;
        this.punish = punish;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public String getPunish() {
        return punish;
    }

    public void setPunish(String punish) {
        this.punish = punish;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", punish='" + punish + '\'' +
                '}';
    }
}

2、创建优秀员工的对象，装成类

package Stream.Test;

public class Topperformer {
    private String name;
    private double money;//月薪

    public Topperformer() {
    }

    public Topperformer(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

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

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

3、正题

public class Test1 {
    public static double allMoney;
    public static double allMoney2;//两个部门去掉最高工资，最低工资的总和

    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("猪八戒",'男',30000,25000,null));
        one.add(new Employee("孙悟空",'男',25000,1000,"顶撞上司"));
        one.add(new Employee("沙僧",'男',20000,20000,null));
        one.add(new Employee("小白龙",'男',20000,25000,null));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("武松",'男',15000,9000,null));
        two.add(new Employee("李逵",'男',20000,10000,null));
        two.add(new Employee("西门庆",'男',50000,10000,"被打"));
        two.add(new Employee("潘金莲",'男',3500,1000,"被打"));
        two.add(new Employee("武大郎",'男',2000,0,"下毒"));

        //1.开发一部的最高工资的员工
        //制定大小规则了
        //Employee e = one.stream().max((e1,e2) -> Double.compare(e1.getSalary() + e1.getBonus() ,e2.getSalary() + e2.getBonus()))
        //        .get();//利用get方法取出
        //System.out.println(e);

        Topperformer t = one.stream().max((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus() ,e2.getSalary() + e2.getBonus()))
                .map(e -> new Topperformer(e.getName(),e.getBonus() + e.getSalary())).get();
        System.out.println(t);
        //直接一步到位，封装成一个优秀员工

        //2.统计平均工资，去掉最高和最低工资
        one.stream().sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus() ,e2.getSalary() + e2.getBonus()))
                .skip(1).limit(one.size() - 2).forEach(e -> {
                    //求出总和：剩余员工的工资总和
                    allMoney += (e.getSalary() + e.getBonus());
                });
        System.out.println("开发一部的平均工资是：" + allMoney / (one.size() -2));

        //3.合并2个集合流，再统计
        Stream<Employee> s1 = one.stream();
        Stream<Employee> s2 = two.stream();
        Stream<Employee> s3 = Stream.concat(s1,s2);

        s3.sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus() ,e2.getSalary() + e2.getBonus()))
                .skip(1).limit(one.size() + two.size() -2).forEach(e -> {
                    //求出总和剩余员工的工资总和
            allMoney2 += (e.getBonus() + e.getSalary());
                });
        //BigDecimal(让数字变得更精确一些)，封装成大数据对象
        BigDecimal a = BigDecimal.valueOf(allMoney2);
        BigDecimal b = BigDecimal.valueOf(one.size() + two.size() -2);
        System.out.println(("开发部的平均工资是：" + a.divide(b,2, RoundingMode.HALF_UP)));//
        //                                             对b求余  保留两位小数          四舍五入
        System.out.println(("开发部的平均工资是：" + allMoney2 / (one.size() + two.size() -2)));// 32071.428571428572
        //                                                                                     不精确，有很多位小数
    }
}

五、收集（终结方法）

目标：收集Stream流的数据到集合或者数组中去

Stream流：方便操作集合，数组的手段

集合，数组：才是开发中的目的 

        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

1、到List集合中

Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
List<String> zhangList = s1.collect(Collectors.toList());//可变集合
zhangList.add("java1");
System.out.println(zhangList );

NOTE： 

得到是不可变集合的（从JDK16开始的）

2、到Set集合中

注意：流只能使用一次，不能反复使用，先把流转成List，又转成Set，会报错的

Stream<String> s2 = list.stream().filter(s -> s.startsWith("张"));
Set<String> zhangSet = s2.collect(Collectors.toSet());
System.out.println(zhangSet);

3、到数组中去

简化前：

 简化后

Stream<String> s3 = list.stream().filter(s -> s.startsWith("张"));
//Object[] arrs = s3.toArray();
//String[] arrs = s3.toArray(s -> new String[s]);
String[] arrs = s3.toArray(String[]::new );//最终简化结果   两个变量相同，都是s（拓展）
System.out.println("Arrays数组内容是：" + Arrays.toString(arrs));