JAVA-Stream流

1.什么是Stream流

在JAVA8中基于Lambda引入的概念，用于简化集合和数组操作的API。

eg: 

（1）从集合中找到姓张的放到新集合
（2）找姓张的名称长度是3的名字

//不使用Stream流

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class StreamTest {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"张三一","李四","王二麻子","张三二","张医","张三三");
        System.out.println(names);

        //1.从集合中找到姓张的放到新集合
        List<String> zhangList = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("张")){
                zhangList.add(name);
            }
        }
        System.out.println(zhangList);
        //2.找姓张的名称长度是3的名字
        List<String> zhangThreeList = new ArrayList<>();
        for (String s : zhangList)
            if (s.length() == 3){
                zhangThreeList.add(s);
        }
        System.out.println(zhangThreeList);


    }

}

//使用Stream流
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StreamTest2 {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"张三一","李四","王二麻子","张三二","张医","张三三");
        System.out.println(names);

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


    }

}

Stream就像一个流水线

1. 先得到集合或者数组的Stream流（就是一根流水线）
2. 把元素放上去
3. 然后用Stream流简化API来方便操作元素

2.Stream流的三类方法

2.1 获取Stream流

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

        //Collection集合获取流
        Collection<String> list = new ArrayList<>();
        Stream<String> s = list.stream();
        
        //Map集合获取流
        Map<String,Integer> maps = new HashMap<>();
        //Map无法直接获取，可以获取键流
        Stream<String> keyStream = maps.keySet().stream();
        //Map无法直接获取，可以获取值流
        Stream<Integer> valueStream = maps.values().stream();
        //拿整体——键值对流
        Stream<Map.Entry<String,Integer>> keyAndValueStream = maps.entrySet().stream();
        
        //数组获取流
        String[] names = {"张三","李四","王二麻子"};
        Stream<String> nameStream = Arrays.stream(names);

2.2 中间方法

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

        //limit：取前几个元素
        //skip:跳过前几个元素
        //map:加工方法
        //concat:合并流

        List<String> list = new ArrayList<>();
        list.add("张三风");
        list.add("李四");
        list.add("王二麻子");
        list.add("赵公子");
        list.add("张三");
        list.add("张起零");



        list.stream().filter(s -> s.startsWith("张")).forEach(s -> 
System.out.println(s));
        long size = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(size);


        list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);

        list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println);

        //Map加工方法
        //给集合元素的前面都加上一个，聪明的
        list.stream().map(s -> "聪明的：" + s).forEach(s -> System.out.println(s));

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

        Stream<String> s1  = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 = Stream.of("2022年","2月","18日");
        Stream<String> s3 = Stream.concat(s1,s2);
        s3.forEach(s -> System.out.println(s));

2.3 终结方法

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

3.综合案例

• 员工信息至少包含了（名称，性别，工资，奖金，处罚记录）
• 开发部门一有4个员工，开发部门二有5名员工
• 分别筛选出2个部门的最高工资的员工信息，封装成优秀员工对象Topperformer
• 分别统计出部门一的平均月收入，要求去掉最高和最低工资
• 统计两个开发部门整体的平均工资，去掉最低和最高工资的平均值

核心代码

ublic class StreamDemo3 {
    public static double allMoney = 0;
    public static double allMoney2 = 0;//两个部门的总和
    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("张三",'男',100000,5000,null));
        one.add(new Employee("李四",'男',150000,2000,"殴打老板"));
        one.add(new Employee("张美丽",'女',200000,10000,null));
        one.add(new Employee("王二麻子",'男',250000,3000,"天天旷工"));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("武松",'男',1500,500,"打死珍惜保护动物"));
        two.add(new Employee("李逵",'男',1200,50,null));
        two.add(new Employee("西门庆",'男',1000,9000,"被打"));
        two.add(new Employee("潘金莲",'男',800,5000,"被打"));
        two.add(new Employee("武大郎",'男',500,100,"被下毒"));
        //1.开发一部门的最高工资员工
        //指定大小规则
        //Employee e = one.stream().max((e1,e2) -> Double.compare(e1.getBonus()+e1.getSalary(), e2.getBonus()+e2.getSalary() )).get();
        //System.out.println(e);
        Topperformer t = one.stream().max((e1,e2) -> Double.compare(e1.getBonus()+e1.getSalary(), e2.getBonus()+e2.getSalary() ))
                .map(e -> new Topperformer(e.getName(), e.getBonus()+e.getSalary())).get();
        System.out.println(t);


        //2.分别统计出两个部门的平均月收入，要求去掉最高和最低工资

        one.stream().sorted((e1,e2) -> Double.compare(e1.getBonus()+e1.getSalary(), e2.getBonus()+e2.getSalary() )).skip(1).limit(one.size()-2)
                .forEach(e ->{
                    //求出总和
                    allMoney += (e.getBonus()+e.getSalary());

                });
        System.out.println("开发一部的平均工资是：" + allMoney/(one.size() - 2));

        //3.合并两个集合流统计
        Stream<Employee> s1 = one.stream();
        Stream<Employee> s2 = two.stream();
        Stream<Employee> s3 = Stream.concat(s1,s2);
        s3.sorted((e1,e2) -> Double.compare(e1.getBonus()+e1.getSalary(), e2.getBonus()+e2.getSalary() )).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));

    }
}

4.Stream流的收集操作

即把Stream流操作后的结果数据转回到集合或者数组中去。

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

集合数组才是开发目的

List<String> list = new ArrayList<>();
        list.add("张三风");
        list.add("李四");
        list.add("王二麻子");
        list.add("赵公子");
        list.add("张三");
        list.add("张起零");

        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        List<String> zhangList = s1.collect(Collectors.toList());
        System.out.println(zhangList);

        //流只能使用一次
        Stream<String> s2 = list.stream().filter(s -> s.startsWith("张"));
        Set<String> zhangSet = s2.collect(Collectors.toSet());
        System.out.println(zhangSet);

        Stream<String> s3 = list.stream().filter(s -> s.startsWith("张"));
        Object[] arrs =s3.toArray();
        System.out.println("Arrays数组内容：" + Arrays.toString(arrs));