java8-强大的Stream API

学习使我快乐，我要去上海的字节跳动，梦想是要有的，万一一不小心实现了呢！！！

1、了解Stream

Java8中有两个最为重要的改变。第一个是Lambda表达式，另外一个则是Stream API(java.util.stream.*)

Stream是Java8中处理集合的关键抽象概念，对集合进行的操作，可以指定非常复杂的

查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行数据库查询。

也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式

【注意】产生一个新流，原来的数据源没有任何改变

2、流（stream）到底是什么？

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

“集合讲的是数据，流讲的是计算”

【注意】

①、Stream 自己不会存储元素

②、Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream

③、Stream操作是延迟执行的。这意味着它们会等到需要结果的时候才执行

3、Stream操作的三个步骤

1）创建Stream

一个数据源（如：集合，数组），获取一个流

2）中间操作

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

3）终止操作

一个终止操作，执行中间操作链，并产生结果

4、创建Stream的四种方式

public class TestStream1 {

    //创建Stream
    @Test
    public void test1(){
        //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、创建无限流
        //迭代  第一个参数：种子   第二个参数：funtion的函数式接口
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
        stream4.limit(10).forEach(System.out::println);

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

}

 

5、Stream 筛选和切片

【注意】多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的

处理！，而是在终止操作时一次性处理，称为“惰性求值”

/**
 * @author houChen
 * @date 2020/12/30 20:18
 * @Description:
 *
 * 流的中间操作
 */
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 - 接受Lambda，从流中排除某些元素
    limit - 截断流，使其元素不超过给定数量
    skip - 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足n，则返回一个空流。
    distinct - 筛选，通过流所生成元素的hashCode()和equals()去除重复元素
     */

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

6、Stream映射

/*
 映射
 map - 接受Lambda,将元素转换成其他形式或提取信息。接受一个函数作为参数，该函数会被应用到每个元素上，并将其
 映射成一个新的元素。
 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();
}

7、Stream 排序

/*
    排序：
    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);
}

 

8、Stream查找与匹配、

查找与匹配

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

9、stream归约与收集

1）归约

reduce(T identity,BinaryOperater) / reduce(BinaryOperater)

可以将流中的元素反复结合起来，得到一个值

identity:起始值

BinaryOperater：二元运算符

【备注】map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名

/**
 * @author houChen
 * @date 2021/1/1 9:32
 * @Description:
 *
 * 归约
 * reduce(T identity,BinaryOperater) / reduce(BinaryOperater)
 * 可以将流中的元素反复结合起来，得到一个值
 * identity:起始值
 * BinaryOperater：二元运算符
 *
 */
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 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);
    }

}

2）收集

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