文章目录

一、流简介
二、创建流
- 2.1 由值创建流：of
- 2.2 由列表创建流：stream
- 2.3 由 Builder 创建流：build
- 2.4 由文件生成流：lines
- 2.5 由函数生成流
- - 2.5.1 迭代（如果不做限制，就是创建无限流）：iterate
  - 2.5.2 生成：generate
三、常用操作
- 3.1 筛选
- - 3.1.1 filter
  - 3.1.2 limit
- 3.2 映射
- - 3.2.1 map
- 3.3 查找和匹配
- - 3.3.1 anyMatch
  - 3.3.2 allMatch
  - 3.3.3 findAny
  - 3.3.4 findFirst
- 3.4 规约
- - 3.4.1 reduce
  - - 3.4.1.1 元素求和
    - 3.4.1.2 最大值
    - 3.4.1.3 最小值
- 3.5 数值流
- - 3.5.1 对象流映射到数值流
  - - 3.5.1.1 mapToInt
    - 3.5.1.2 mapToDouble
    - 3.5.1.3 mapToLong
  - 3.5.2 数值流转换回对象流
  - - 3.5.2.1 boxed
  - 3.5.3 数值流的应用

一、流简介

流式 API 从 Java8 开始引入，支持链式书写。
流在管道中流通，在节点被处理。
Stream是独特的，既不同于io，也不同于List。
Stream在理论上能容纳无限对象，List不能
流不是一种数据结构，流存储的只是一种数据视图。
流的计算是惰性计算，真正的计算通常只发生在最后的结果获取时。流式计算存在第一步、中间一步、最后一步的说法，只有当到达最后一步执行函数的时候，整个惰性函数才会执行。
流只能消费一次，不能被两次消费

如下的代码，对stream进行了两次遍历，所以会报错

List<String> stringList = Arrays.asList("Java", "Python", "C++", "Matlab");
        Stream<String> stream = stringList.stream();
        stream.forEach(System.out::println);
        stream.forEach(System.out::println);

在这里插入图片描述

二、创建流

2.1 由值创建流：of

方法一：使用静态方法 Stream.of() ，通过显式值创建一个流

        Stream<String> stream = Stream.of("Java","Python","C++","Matlab");

        String[] arr = new String[]{"Java","Python","C++","Matlab"};
        Stream<String> stream = Stream.of(arr);

2.2 由列表创建流：stream

方法二：使用 Collection 的 stream() 方法，创建一个流

        List<String> list = Arrays.asList("Java","Python","C++","Matlab");
        Stream<String> stream = list.stream();

2.3 由 Builder 创建流：build

方法三：使用 builder() 创建一个流

        Stream<String> stream = Stream.<String>builder()
                .add("Java")
                .add("Python")
                .add("C++")
                .add("Matlab")
                .build();

2.4 由文件生成流：lines

方法四：使用 Files.lines() 创建一个流

        Stream<String> stream = null;
        try {
            stream = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());
        }catch (IOException e){
            e.printStackTrace();
        }

2.5 由函数生成流

2.5.1 迭代（如果不做限制，就是创建无限流）：iterate

        Stream<Integer> stream = Stream.iterate(0, n -> n + 2)
                .limit(10);
        stream.forEach(System.out::println); // 0,2,4,6,8,10,12,14,16,18

下面用迭代的方法生成斐波那契数列：

        Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
                .limit(10)
                .forEach(t -> {
                    System.out.println(t[0] + " " + t[1]);
                });

输出如下：

2.5.2 生成：generate

下面是生成 4 个随机数的代码

        // 0.24958123386777675,0.3934127178560789,0.45154850021573034,0.005268717434774417,
        Stream.generate(Math::random)
                .limit(4)
                .forEach(num -> System.out.print(num + ","));

三、常用操作

这是下面例子中会用到的学生对象，下面会利用流式编程，对学生列表进行一系列操作

    static class Student{
        String name;
        int age;
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

下面是获取学生列表的函数，后面都会以这个学生列表进行举例说明

    public static List<Student> createStudentList(){
        return Arrays.asList(
                new Student("WSKH",21),
                new Student("WRQ",22),
                new Student("SXC",20),
                new Student("XCY",36),
                new Student("CZG",40),
                new Student("LHH",18)
        );
    }

在后面，假设我们已经通过上面的函数获取到了学生列表，并将其命名为 studentList

List<Student> studentList = createStudentList();

3.1 筛选

3.1.1 filter

filter()：返回一个包括所有符合谓词的元素的流

应用实例：获取年龄在 25 以下的学生

        List<Student> result = studentList.stream().filter(student -> {
            return student.age < 25;
        }).collect(Collectors.toList());

3.1.2 limit

limit(n)：该方法会返回一个不超过给定长度的流

应用实例：获取年龄在25以下的学生，并且要求结果中的学生不超过2位

        List<Student> result = studentList.stream().filter(student -> {
            return student.age < 25;
        }).limit(2).collect(Collectors.toList());

3.2 映射

3.2.1 map

map()：对流中每一个元素应用函数

应用案例：获取所有学生的年龄

        List<Integer> result = studentList.stream().map(student -> {
            return student.age;
        }).collect(Collectors.toList());

应用案例：获取所有学生的名字

        List<String> result = studentList.stream().map(student -> {
            return student.name;
        }).collect(Collectors.toList());

3.3 查找和匹配

3.3.1 anyMatch

anyMatch()：判断流中是否有一个元素能匹配给定的谓词

应用案例：判断是否有小于等于18岁的学生

        boolean b = studentList.stream().anyMatch(student -> student.age <= 18);

3.3.2 allMatch

allMatch()：判断流中的元素是否都能匹配给定的谓词

应用案例：判断是否所有的学生都大于18岁

        boolean b = studentList.stream().allMatch(student -> student.age > 18);

3.3.3 findAny

findAny()：返回当前流中的任意元素

应用案例：获取任意一个大于25岁的学生

        Optional<Student> any = studentList.stream().filter(student -> {
            return student.age > 25;
        }).findAny();
        System.out.println(any); // Optional[Student{name='XCY', age=36}]

3.3.4 findFirst

findFirst()：返回当前流中的第一个元素

应用案例：获取学生列表中第一个大于25岁的学生

        Optional<Student> first = studentList.stream().filter(student -> {
            return student.age > 25;
        }).findFirst();
        System.out.println(first); // Optional[Student{name='XCY', age=36}]

3.4 规约

3.4.1 reduce

reduce(p1,p2)：操作组合流中的所有元素以产生单个值。
reduce的第一个参数：初始值，相当于给求和或者求最大最小值一个初值
reduce的第二个参数：一个BinaryOperator来将两个元素结合起来产生一个新值

3.4.1.1 元素求和

应用案例：求出学生们的年龄总和

        int sum = studentList.stream().map(student -> {
            return student.age;
        }).reduce(0, (a, b) -> a + b);
        System.out.println(sum); // 157

也可以简写如下，用 Integer::sum 简化 (a, b) -> a + b

        int sum = studentList.stream().map(student -> {
            return student.age;
        }).reduce(0, Integer::sum);
        System.out.println(sum); // 157

3.4.1.2 最大值

应用案例：求出学生们的最大年龄

        int maxAge = studentList.stream().map(student -> {
            return student.age;
        }).reduce(0, (a, b) -> a > b ? a : b);
        System.out.println(maxAge); // 40

3.4.1.3 最小值

应用案例：求出学生们的最小年龄

        int minAge = studentList.stream().map(student -> {
            return student.age;
        }).reduce(Integer.MAX_VALUE, (a, b) -> a < b ? a : b);
        System.out.println(minAge); // 18

3.5 数值流

在Java中，因为Java泛型不支持基本类型，所以我们无法使用像Stream这样的形式来保存int，只能采用形如Integer这样的形式。但是频繁装箱、拆箱操作会牺牲编译器的大量性能。

所以为了提高效率，Java标准库提供了三种使用基本类型的Stream，它们的使用和标准的Stream没有太大区别，直接使用：

IntStream
LongStream
DoubleStream

他们也被称为数值流。

3.5.1 对象流映射到数值流

3.5.1.1 mapToInt

mapToInt()：返回一个 IntStream（而不是一个Stream）

        IntStream intStream = studentList.stream().mapToInt(student -> student.age);

3.5.1.2 mapToDouble

mapToDouble()：返回一个 DoubleStream（而不是一个Stream）

        DoubleStream doubleStream = studentList.stream().mapToDouble(student -> student.age);

3.5.1.3 mapToLong

mapToLong()：返回一个 LongStream（而不是一个Stream）

        LongStream longStream = studentList.stream().mapToLong(student -> student.age);

3.5.2 数值流转换回对象流

3.5.2.1 boxed

boxed()：要把原始流转换成一般流（这里每个int都会装箱成一个Integer）

        IntStream intStream = studentList.stream().mapToInt(student -> student.age);
        Stream<Integer> boxed = intStream.boxed();

3.5.3 数值流的应用

应用案例：求出学生们的年龄总和

        int sum = studentList.stream().mapToInt(student -> student.age).sum();
        System.out.println(sum); // 157

应用案例：求出学生们的最大年龄

        OptionalInt max = studentList.stream().mapToInt(student -> student.age).max();
        System.out.println(max.isPresent() ? max.getAsInt() : "不存在最大值"); // 40

应用案例：求出学生们的最小年龄

        OptionalInt min = studentList.stream().mapToInt(student -> student.age).min();
        System.out.println(min.isPresent() ? min.getAsInt() : "不存在最小值"); // 18

应用案例：求出学生们的平均年龄

        OptionalDouble average = studentList.stream().mapToInt(student -> student.age).average();
        System.out.println(average.isPresent() ? average.getAsDouble() : "不存在平均值"); // 26.166666666666668

应用案例：求出大于25岁的学生的数量

        long count = studentList.stream().mapToInt(student -> student.age).filter(age -> {
            return age > 25;
        }).count();
        System.out.println(count); // 2