Java基础：如何使用Stream？

小鱼儿 2024-03-23 15:43 9阅读 0赞

![format_png][]

### 1. Stream 的使用 ###

> **Stream 是什么？**

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

Java8两大最为重要的改变就是 **Lambda表达式** 与 **Stream API**，这两种改变的引入带来的是新的抽象方式 **（函数式编程）**，面向对象编程是对数据进行抽象，而**函数式编程是对行为进行抽象**

Stream 是 Java8 中处理集合的关键抽象概念，可以指定对集合进行的操作，可以执行复杂的查找、过滤、映射数据等操作，Stream API 提供了一种高效且易于使用的处理数据的方式。

--------------------

> 四个必须要知道的内置函数接口
> 
> 1.  消费型接口: `Consumer<T> void accept(T t)` 有参数，无返回值的抽象方法；
> 2.  供给型接口: `Supplier <T> T get()` 无参有返回值的抽象方法；
> 3.  断定型接口: `Predicate<T> boolean test(T t)` 有参，但是返回值类型是固定的boolean;
> 4.  函数型接口: `Function<T,R> R apply(T t)` 有参有返回值的抽象方法；

// 消费接口定义
    Consumer<Student> greeter = (p) -> System.out.println("Hello, " + p.firstName);
    // 消费
    greeter.accept(new Student("Luke", "Skywalker"));
    复制代码

// 供给接口定义
    Supplier<Student> supplier = Student::new;
    // 供给
    supplier.get();
    复制代码

// 断定型接口定义
    Predicate<String> predicate = (s) -> s.length() > 0;
    // 断定
    predicate.test("s");              // true
    predicate.test("");     // false
    复制代码

// 函数型接口定义
    Function<String, Integer> toInteger = Integer::valueOf;
    Function<String, String> backToString = toInteger.andThen(String::valueOf);
    // 应用
    backToString.apply("123");     // "123"
    复制代码

![format_png 1][]

--------------------

> Stream 的使用分为三个步骤
> 
> 1.  创建Stream （使用数据源可以是集合、数组来获取流）
> 2.  中间操作 （对数据源的数据进行处理）
> 3.  终止操作 （先执行中间操作产生结果后终止流，之后不能再使用该流）

![format_png 2][]

> **惰性求值**
> 
> 中间操作不会执行任何的处理，而是在**终止操作时一次性全部处理**，这就是惰性求值

// 像这样的代码并未做什么实际工作
    lists.stream().filter(x -> x != 1)
    复制代码

// 像这种有终止操作的代码才会产生新值
    List<Integer> list1 = list.parallelStream().filter(x -> x != 1).collect(Collectors.toList());
    复制代码

--------------------

#### 1.1 创建 Stream 的方式 ####

> 集合创建
> 
> 1.  顺序流：使用顺序方式遍历，每个item读完之后再读下一个item
> 2.  并行流：使用并行遍历，将数据分为多个段，各个段的数据都在不同线程下处理
> 
> 在多核计算机的情况下理论上并行流会比顺序流快上一倍左右

① 顺序执行：`default Stream<E> stream()` 返回一个顺序流

// 将list列表通过stream()生一个流过滤1最后打印
    List<Integer> list1 = list.stream().filter(x -> x != 1).collect(Collectors.toList());
    复制代码

② 并行执行：`default Stream<E> parallelStream()` 返回一个并行流

List<Integer> list1 = list.parallelStream().filter(x -> x != 1).collect(Collectors.toList());
    复制代码

> 数组创建

通过**Arrays**的**静态方法**获取数组流：`static <T> Stream<T> stream(T[] array)`

// 将array数组通过Arrays的静态方法生一个流过滤1最后打印
    Arrays.stream(array).filter(x -> x != 1).forEach(System.out::println);
    复制代码

> Stream创建

通过**调用Stream类的静态方法**创建流 （注意后两个生成的是无限流）

① 通过显示值：`public static<T> Stream<T> of(T... values)`

// 通过显示值1，2，3，4生成一个流过滤掉1最后打印
    Stream.of(1,2,3,4).filter(x -> x != 1).forEach(System.out::println);
    复制代码

② 通过迭代：`public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)`

// 从0开始迭代每次加1生成一个无限流通过limit限制前十位最后打印
    Stream.iterate(0, x -> x + 1).limit(10).forEach(System.out::println);
    复制代码

③ 通过生成：`public static<T> Stream<T> generate(Supplier<T> s)`

// 通过Math的随机数函数生成一个无限流通过limit限制前五位最后打印
    Stream.generate(Math::random).limit(5).forEach(System.out::println);
    复制代码

--------------------

#### 1.2 中间操作 ####

> **`Stream<T> filter(Predicate<? super T> predicate);`**
> 
> 接收Lambda，从流中排除某些元素；

List<Integer> list = Arrays.asList(1,2,3,4);
    
    // filter中传入一个判定型接口Predicate过滤掉遍历这个集合是返回false的结果
    List<Integer> list1 = list.stream().filter(x -> x != 1).collect(Collectors.toList());
    
    list1.forEach(System.out::print); // 234
    复制代码

> **`Stream<T> distinct();`**
> 
> 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素;

List<Integer> nums = Arrays.asList(1,1,2,3,4);
    // 去重
    nums.stream().distinct().forEach(System.out::print); // 1234
    复制代码

> **`Stream<T> limit(long maxSize);`**
> 
> 截断流，使其元素不超过给定数量

// 通过Math的随机数函数生成一个无限流通过limit限制前五位最后打印
    Stream.generate(Math::random).limit(5).forEach(System.out::println);
    复制代码

> **`Stream<T> skip(long n);`**
> 
> 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

List<Integer> nums = Arrays.asList(1,1,2,3,4);
    // 去重
    nums.stream().skip(2).forEach(System.out::print); // 234
    复制代码

> **`<R> Stream<R> map(Function<? super T, ? extends R> mapper);`**
> 
> 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

List<Integer> nums = Arrays.asList(1,1,2,3,4);
    // 通过map对每个元素进行类型转换
    List<Long> collect = nums.stream().map(Long::valueOf).collect(Collectors.toList());
    复制代码

> **`<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);`**
> 
> 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

// 合并多个流
    List<Integer> result= Stream.of(Arrays.asList(1,3),Arrays.asList(5,6)).flatMap(Collection::stream).collect(Collectors.toList());
    复制代码

> **`Stream<T> sorted();`**
> 
> 产生一个新流，其中按自然顺序排序

List<Integer> nums = Arrays.asList(8,6,7,3);
    // 自然排序
    nums.stream().sorted().forEach(System.out::print); // 3678
    复制代码

> **`Stream<T> sorted(Comparator<? super T> comparator);`**
> 
> 产生一个新流，其中按比较器顺序排序

List<Integer> nums = Arrays.asList(8,6,7,3);
    // 比较器排序
    nums.stream().sorted((x,y) -> (y-x)).forEach(System.out::print); // 8763
    复制代码

--------------------

#### 1.3 终止操作 ####

> **`boolean allMatch(Predicate<? super T> predicate);`**
> 
> 检查是否匹配所有元素

List<Integer> nums = Arrays.asList(1,1,7,3);
    // 检查是否集合里面的元素都等于1
    System.out.println(nums.stream().allMatch(x -> x == 1)); // false
    复制代码

> **`boolean anyMatch(Predicate<? super T> predicate);`**
> 
> 检查是否至少匹配一个元素

List<Integer> nums = Arrays.asList(1,1,7,3);
    // 检查是否集合里面的元素有等于1的
    System.out.println(nums.stream().anyMatch(x -> x == 1)); // true
    复制代码

> **`boolean noneMatch(Predicate<? super T> predicate);`**
> 
> 检查是否没有匹配所有元素

List<Integer> nums = Arrays.asList(1,1,7,3);
    // 检查是否集合里面的元素都不等于1
    System.out.println(nums.stream().noneMatch(x -> x == 1)); // false
    复制代码

> **`Optional<T> findFirst();`**
> 
> 返回第一个元素

List<Integer> nums = Arrays.asList(1,1,7,3);
    // 拿到集合第一个元素用Optional存储可以通过get取出来
    System.out.println(nums.stream().findFirst()); // Optional[1]
    System.out.println(nums.stream().findFirst()); // 1
    复制代码

> **`Optional<T> findAny();`**
> 
> 返回当前流中的任意元素

List<Integer> nums = Arrays.asList(1,1,7,3);
    // 拿到集合任意元素用Optional存储可以通过get取出来
    System.out.println(nums.stream().findFirst()); // Optional[1]
    System.out.println(nums.stream().findFirst()); // 1
    复制代码

> **`long count();`**
> 
> 返回流中元素总数

List<Integer> nums = Arrays.asList(3,7,3);
    // 集合大小
    System.out.println(nums.stream().count()); // 3
    复制代码

> **`Optional<T> max(Comparator<? super T> comparator);`**
> 
> 返回流中最大值

List<Integer> nums = Arrays.asList(3,7,3);
    // 返回比较器下的最大值用Optional存储通过get取出(注意这里的比较器是从大到小排序)
    System.out.println(nums.stream().max((x, y) -> (y - x)).get()); // 3
    复制代码

> **`Optional<T> min(Comparator<? super T> comparator);`**
> 
> 返回流中最小值

List<Integer> nums = Arrays.asList(3,7,3);
    // 返回比较器下的最小值用Optional存储通过get取出(注意这里的比较器是从大到小排序)
    System.out.println(nums.stream().min((x, y) -> (y - x)).get()); // 7
    复制代码

> **`void forEach(Consumer<? super T> action);`**
> 
> 内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代)

List<Integer> nums = Arrays.asList(3,7,3);
    // 内部迭代
    nums.stream().forEach(System.out::print); // 373
    复制代码

> **`Optional<T> reduce(BinaryOperator<T> accumulator);`**
> 
> 可以将流中元素反复结合起来，得到一个值。返回 T

List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
    // 将集合的值变成double类型并抹个零通过reduce反复结合即相加得到总和
    double bill = costBeforeTax.stream().map((cost) -> 0.1 * cost).reduce(Double::sum).get();
    System.out.println(bill); // 150.0
    复制代码

> **`T reduce(T identity, BinaryOperator<T> accumulator);`**
> 
> 可以将流中元素反复结合起来，得到一个值。返回 `Optional<T>`

double bill = 100.0;
    List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
    // 跟上面的比就是多一个初始值在反复结合
    bill = costBeforeTax.stream().map((cost) -> 0.1 * cost).reduce(bill, Double::sum);
    System.out.println(bill); // 250.0
    复制代码

> **`<R, A> R collect(Collector<? super T, A, R> collector);`**
> 
> 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

![format_png 3][]

![format_png 4][]

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/eda0af9c86c045cba1b0ed706a8372a7.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/d3bcba2002284958886da1ed1aeaf55d.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/d1af1d70791e46e9b4034fbf5406f414.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c9694d1ebd174f7f803d7ee344f4a363.png
[format_png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/8700746097304e8a8b16747060592f28.png