【Java8新特性】四、强大的Stream api

这里写自定义目录标题

一、了解Stream
二、流(stream)到底是什么？
三、Stream操作的三个步骤
四、创建Stream的四种方式
五、Stream 的中间操作
- 1、筛选和切片
- 2、map 映射
- 3、排序
六、Stream 的终止操作
- 1、查找和匹配
- 2、归约
- 3、收集

一、了解Stream

Stream是Java8中处理集合的一个工具

二、流(stream)到底是什么？

流是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列

【注意】
①、Stream 自己不会存储元素
②、Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
③、Stream操作是延迟执行的。这意味着它们会等到需要结果的时候才执行

三、Stream操作的三个步骤

创建Stream
一个数据源(如：集合，数组)，获取一个流

2)中间操作
一个中间操作链，对数据源的数据进行处理

3)终止操作
一个终止操作，执行中间操作链，并产生结果
在这里插入图片描述

四、创建Stream的四种方式

1、可以通过Collection系列集合提供的stream()或 parallelStram() 创建流

  List<String> list = new ArrayList<>();
  Stream<String> stream1 = list.stream();

2、通过Arrays中的静态方法stream()来获取数组流

  Employee[] emps = new Employee[10];
  Stream<Employee> stream2 = Arrays.stream(emps);

3、通过Stream中的静态方法 of() 创建流

 Stream<String> stream3 =  Stream.of("aa","bb","cc");

4、由函数创建流：创建无限流

Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
stream4.limit(10).forEach(System.out::println);


Stream<Double> s = Stream.generate(() -> Math.random());
s.limit(10).forEach(System.out::println);

五、Stream 的中间操作

【注意】多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的
处理！，而是在终止操作时一次性处理，称为“惰性求值”

1、筛选和切片

filter - 接受Lambda，从流中排除某些元素
limit - 截断流，使其元素不超过给定数量
skip - 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足n，则返回一个空流。
distinct - 筛选，通过流所生成元素的hashCode()和equals()去除重复元素

public class TestStream2 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,3000),
            new Employee("李四",45,4000),
            new Employee("王五",37,3000),
            new Employee("赵六",18,6000),
            new Employee("田七",40,10000),
            new Employee("田七",40,10000));

    //filter
    //内部迭代：迭代操作由Stream API完成
    @Test
    public void test1(){
        //中间操作不会不会有任何结果
        Stream<Employee> sm = employees.stream().filter((e) -> e.getAge() > 25);
        //终止操作
        //sm.forEach((e) -> System.out.println(e));
        sm.forEach(System.out::println);
    }


    //limit
    @Test
    public void test2(){
       employees.stream().filter((e) -> e.getAge() > 25)
               .limit(2).forEach(System.out::println);
    }


    //skip
    @Test
    public void test3(){
        employees.stream().filter((e) -> e.getAge() > 25)
                .skip(2).forEach(System.out::println);
    }

    //distinct() 【注意】比较的元素需要equals()方法
    @Test
    public void test4(){
        employees.stream().filter((e) -> e.getAge() > 25)
                .skip(2).distinct().forEach(System.out::println);
    }
}

2、map 映射

map：接收一个函数作为参数，该函数会被用到每个元素上，并将其映射成一个新的元素
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

@Test
    public void test5(){
        List<String> list = Arrays.asList("aaa","bb","ccc");
        list.stream().map((str) -> str.toUpperCase())
                .forEach(System.out::println);


        System.out.println("-----------------------------------");
        employees.stream().map(Employee::getName)
                .forEach(System.out::println);

        System.out.println("------------------------------------");
        Stream<Stream<Character>> sm = list.stream().map(TestStream2::filterCharacter);
        sm.forEach((stm) -> stm.forEach(System.out::println));

        System.out.println("------------------------------------");
        System.out.println("上述代码优化");
        list.stream().flatMap(TestStream2::filterCharacter).forEach(System.out::println);
    }

//方法：将字符串转换成一个流
public static Stream<Character> filterCharacter(String str){
    List<Character> list = new ArrayList<>();

    for(Character c: str.toCharArray()){
        list.add(c);
    }

    return list.stream();
}

3、排序

sorted() : 自然排序
sorted(Comparator com) ：定制排序

 @Test
    public void test6(){
        List<String> list = Arrays.asList("aaa","bb","ccc");
        list.stream().sorted()
                .forEach(System.out::println);

        System.out.println("------------------------------------");
        list.stream().sorted((x,y) -> -x.compareTo(y))
                .forEach(System.out::println);
    }

六、Stream 的终止操作

1、查找和匹配

allMatch - 检查是否匹配所有元素
anyMatch - 检查是否至少匹配一个元素
noneMatch - 检查是否没有匹配所有元素
findFirst - 返回第一个元素
FindAny - 返回当前流中的任意元素
count - 返回当前流中元素的总个数
max - 返回流中的最大值
min - 返回流中的最小值

public class TestStream3 {


    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,3000, Employee.Status.Free),
            new Employee("李四",45,4000, Employee.Status.Free),
            new Employee("王五",37,3000, Employee.Status.Busy),
            new Employee("赵六",18,6000, Employee.Status.Vocation),
            new Employee("田七",40,10000, Employee.Status.Vocation)
    );

    /*
     查找与匹配
     allMatch - 检查是否匹配所有元素
     anyMatch - 检查是否至少匹配一个元素
     noneMatch - 检查是否没有匹配所有元素
     findFirst - 返回第一个元素
     FindAny - 返回当前流中的任意元素
     count - 返回当前流中元素的总个数
     max - 返回流中的最大值
     min - 返回流中的最小值
    */
    @Test
    public void test(){
        //allMatch
        boolean b = employees.stream()
                .allMatch((e) -> e.getStatus().equals(Employee.Status.Busy));
        System.out.println(b);

        //anyMatch
        System.out.println(employees.stream().anyMatch((e) -> e.getStatus().equals(Employee.Status.Busy)));
    
        //findFirst
        //Optional: 容器类
        Optional<Employee> op = employees.stream()
                .sorted((x, y) -> -Double.compare(x.getSalary(), y.getSalary()))
                .findFirst();
        op.orElse(new Employee());  // orElse: 如果为空，则用什么来代替
        Employee e = op.get();
        System.out.println(e);
    }

    @Test
    public void test1(){
        long count = employees.stream().count();
        System.out.println(count);

        Optional<Employee> max = employees.stream().max((x, y) -> -Double.compare(x.getSalary(), y.getSalary()));
        System.out.println(max.get());


        //最少的工资是多少
        Optional<Double> min = employees.stream()
                .map(Employee::getSalary)
                .min(Double::compare);
        System.out.println(min.get());
    }
}

2、归约

reduce(T identity,BinaryOperater) / reduce(BinaryOperater)：可以将流中元素反复结合起来，得到一个值。返回 T

public void test(){
        List<Integer> list = Arrays.asList(1,2,3,4,5);

        //0称之为起始元素，将0作为x，在流中取出一个元素作为y,
        //然后将相加的结果作为x,再从流中取出一个元素作为y相加...
        //一直到流中的元素全部加完
        Integer sum = list.stream()
                .reduce(0, (x, y) -> x + y);
        System.out.println(sum);

        System.out.println("------------------------------");
        //获取当前公司中，工资的总和
        Double sumSalary = employees.stream()
                .map(Employee::getSalary)
                .reduce(0d, (x, y) -> x + y);
        System.out.println(sumSalary);
    }

3、收集

collect(Collector c)
collect - 将流转换成其他形式，接受一个Collector接口的实现，
用于给stream中元素做汇总的方
Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到List，Set，Map)
但是Collectors实用类提供了很多静态方法，可以方便地创建常用收集器实例，具体方法和实例如下demo：

/**
 * @author houChen
 * @date 2021/1/1 9:32
 * @Description:
 *
 *
 * 收集
 * collect - 将流转换成其他形式，接受一个Collector接口的实现，
 * 用于给stream中元素做汇总的方法
 */
public class TestStream4 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,3000, Employee.Status.Free),
            new Employee("李四",45,4000, Employee.Status.Free),
            new Employee("王五",37,3000, Employee.Status.Busy),
            new Employee("赵六",18,6000, Employee.Status.Vocation),
            new Employee("田七",40,10000, Employee.Status.Vocation)
    );


    @Test
    public void test2(){
        List<String> names = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());

        for (String name: names) {
            System.out.println(name);
        }

        System.out.println("-------------------------------------------");
        //将结果收集到特殊的集合中
        HashSet<String> set = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        set.forEach(System.out::println);
    }


    @Test
    public void test3(){
        //总数
        Long count = employees.stream()
                .collect(Collectors.counting());
        System.out.println(count);

        System.out.println("---------------------------------");
        //求平均年龄
        Double avgAge = employees.stream()
                .collect(Collectors.averagingDouble(Employee::getAge));
        System.out.println(avgAge);

        System.out.println("---------------------------------");
        //总和
        Double sumSalary = employees.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sumSalary);

        //最大值
        Optional<Employee> maxSalary = employees.stream()
                .collect(Collectors.maxBy((x, y) -> Double.compare(x.getSalary(), y.getSalary())));
        System.out.println(maxSalary.get());
    }

    //分组
    @Test
    public void test4(){
        Map<Employee.Status, List<Employee>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus));

        Set<Employee.Status> statuses = map.keySet();
        Iterator<Employee.Status> iterator = statuses.iterator();
        while (iterator.hasNext()){
            Employee.Status next = iterator.next();
            System.out.println(next+":"+map.get(next));
        }
    }

    //多级分组 : 先按照状态分组，再按照青年、老年分组
    @Test
    public void test5(){
        Map<Employee.Status, Map<String, List<Employee>>> maps = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus,
                        Collectors.groupingBy((e) -> {
                            if (((Employee) e).getAge() <= 35) {
                                return "青年";
                            } else {
                                return "老年";
                            }
                        })));
        System.out.println(maps);
    }

    //分区:
    //   满足条件的为一个区
    //   不满足条件的为一个区
    @Test
    public void test6(){
        Map<Boolean, List<Employee>> map = employees.stream()
                .collect(Collectors.partitioningBy(e -> e.getSalary() > 8000));
        System.out.println(map);
    }
    
    //将员工所有的名字取出来，并用"," 分隔
    @Test
    public void test7(){
        String namestr = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.joining(","));
        System.out.println(namestr);
    }
}