53 Stream API

2024-01-23 20:20:04

Stream API

Java8中有两大最为重要的改变。第一个是Lambda表达:另外一个则是Stream API。
Stream APl ( java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。

Stream 和Collection集合的区别:Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU 实现计算。

集合讲的是数据，Stream讲的是计算

注意:

①Stream自己不会存储元素。
②stream不会改变源对象。相反，他们会返回一个持有结果的新Stream.

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

Stream 的操作三个步骤

1. 创建Stream
一个数据源(如：集合、数组)，获取一个流，Stream的实例化
1. 中间操作
一个中间操作链，对数据源的数据进行处理（过滤、映射）
1. 终止操作(终端操作)
一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

Stream的实例化

创建 Stream方式一:

//创建 Stream方式一：通过集合
        //EmployeeData里的getEmployees()方法
        List<Employee> employees = EmployeeData.getEmployees();
        // default Stream<E> stream() : 返回一个顺序流
        Stream<Employee> stream = employees.stream();

        // default Stream<E> parallelStream() : 返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();

创建 Stream方式二：

//创建 Stream方式二：通过数组
        //调用Arrays类的 static <T> Stream <T> stream(T[] array)：返回一个流
        int[] arr = new int[]{1,2,3,4,5};
        IntStream stream = Arrays.stream(arr);

创建Stream方式三：

//创建 Stream方式三：通过Stream的of()
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);

创建Stream方式四：

        //创建 Stream方式四：创建无限流
        //迭代
        //public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t -> t +2).limit(10).forEach(System.out::println);


        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

Stream的中间操作

筛选与切片

List<Employee> list = EmployeeData.getEmployees();
        //filter(Predicate p)——接收Lambda.从流中排除某些元素
        Stream<Employee> stream = list.stream();
        //练习：查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);

        //limit(n)———截浙流,使其元素不超过给定数量。
        list.stream().limit(3).forEach(System.out::println);


        //skip(n) ——跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
        list.stream().skip(3).forEach(System.out::println);

        //distinct0——筛选，通过流所生成元素的hashCode和 equals去除重复元素
        list.stream().distinct().forEach(System.out::println);

映射

        //map(Function f)——接收一个函数，将元素转换成其他形式或提取信息，
        // 该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("AA", "BB", "CC", "DD");
        list.stream().map(str -> str.toLowerCase()).forEach(System.out::println);



        //练习1:获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);

        //练习2：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest::fromStringToStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });


        //flatMap(Function f)—接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest::fromStringToStream);
        characterStream.forEach(System.out::println);

    }

    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()){
            list.add(c);
        }
        return list.stream();


    }

排序

 //sorted()  自然排序
        List<Integer> list = Arrays.asList(89, 58, 485, -11, 0, 7, 552, 11);
        list.stream().sorted().forEach(System.out::println);

        //报异常，原因：Employee没有实现Comparable接口
//        List<Employee> employees = EmployeeData.getEmployees();
//        employees.stream().sorted().forEach(System.out::println);


        //sorted(Comparator com)  定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1,e2) -> Integer.compare(e1.getAge(),e2.getAge()))
                .forEach(System.out::println);

Stream的终止操作

匹配与查找

List<Employee> employees = EmployeeData.getEmployees();

        //allMatch(Predicate p)-检查是否匹配所有元素。
        // 练习:是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);


        //anyMatch(Predicate p)——检查是否至少匹配一个元素。
        // 练习:是否存在员工的工资大于10000
        boolean match = employees.stream().allMatch(e -> e.getSalary() > 1000);
        System.out.println(match);

        //noneMatch(Predicate p)—检查是否没有匹配的元素。
        // 练习:是否存在员工姓"富
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);//有返回false

        //findFirst—返回第一个元素
        Optional<Employee> optional = employees.stream().findFirst();

        //findAny———返回当前流中的任意元素
        Optional<Employee> optional1 = employees.parallelStream().findAny();

        // count—返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);

        //max(Comparator c)—返回流中最大值
        // 练习:返回最高的工资:
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> max = salaryStream.max(Double::compare);
        System.out.println(max);

        //min(Comparator c—返回流中最小值
        // 练习:返向最低工资的员工
        Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));

        //forEach(Consumer c)  内部迭代
        employees.stream().forEach(System.out::println);

归约

    //reduce(T identity, BinaryOperator)：可以将流中元素反复结合起来，得到一个值。返回T
    //练习1：计算1-10的自然数的和
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    Integer sum = list.stream().reduce(0, Integer::sum);


    //reduce(BinaryOperator) 可以将流中元素反复结合起来，得到一个值。返回Optional<T>
    //练习2：计算公司所有员工工资的总和
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
//  Optional<Double> sumSalary = salaryStream.reduce(Double::sum);
    Optional<Double> sumSalary = salaryStream.reduce((d1,d2) -> d1+d2);

收集

Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到List、Set、Map)。
另外，Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表:

//collect(Collector c)：collect(Collector c)——将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
        //练习1：查找工资大于6000的员工，结果返回为一个list或set

        List<Employee> list = EmployeeData.getEmployees();

		//有序
        List<Employee> employeeList = list.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
		
		//无序
        Set<Employee> employeeSet = list.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());

        employeeList.forEach(System.out::println);

Optional 类

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

Optional类(java.util.Optional)是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用null表示一个值不存在，现在 Optional可以更好的表达这个概念。并且可以避免空指针异常。

Optional类的Javadoc描述如下:这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

 //Optional.of(T t) :创建一个Optional实例，t必须非空;
        //of(T t):保证 t 是非空的
        Girl girl = new Girl();
        Optional<Girl> optionalGirl = Optional.of(girl);

        // optional.emptyo :创建一个空的OptionaL实例

		Girl girl = new Girl();
 		//Optional.ofNullable(T t): t可以为null
        //ofNullable(T t):保证 t 可以为null
        Optional<Girl> optionalGirl = Optional.ofNullable(girl);

Optional类：为了在程序中避免出现空指针异常而创建的。

常用的方法：ofNullable(T t)

orElse(T t)

 //使用Optional类的getGirlName();
    public String getGirlName2(Boy boy){

        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        //orElse(T t1):如果当前的Optional内部封装的t是非空的，则返回内部的t
        //如果内部的t是空的，则返回orElse()方法中的参数t1
        //此时的boy1一定非空
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("iu")));

        Girl girl = boy1.getGirl();

        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        //此时的girl1一定非空
        Girl girl1 = girlOptional.orElse(new Girl("李知恩"));

        return girl1.getName();

码农公寓

Stream API

Stream的实例化

Stream的中间操作

Stream的终止操作

Optional 类

相关文章