【Java】流式编程学习笔记

创始人

2024-05-13 04:17:02

0次

文章目录

一、流简介
二、创建流
- 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 stringList = Arrays.asList("Java", "Python", "C++", "Matlab");Stream stream = stringList.stream();stream.forEach(System.out::println);stream.forEach(System.out::println);

在这里插入图片描述

二、创建流

2.1 由值创建流：of

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

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

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

2.2 由列表创建流：stream

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

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

2.3 由 Builder 创建流：build

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

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

2.4 由文件生成流：lines

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

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

2.5 由函数生成流

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

        Stream 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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}}

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

    public static List 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 studentList = createStudentList();

3.1 筛选

3.1.1 filter

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

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

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

3.1.2 limit

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

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

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

3.2 映射

3.2.1 map

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

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

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

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

        List 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 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 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 boxed = intStream.boxed();

3.5.3 数值流的应用