万字详解 | Java 流式编程

概述

Stream API 是 Java 中引进的一种新的数据处理办法。它供给了一种高效且易于运用的办法来处理数据调集。Stream API 支撑函数式编程，能够让咱们以简练、高雅的办法进行数据操作，还有运用 Stream 的两大原因：

1. 在大多数状况下，将目标存储在调集中就是为了处理它们，因而你会发现你把编程 的首要焦点从调集转移到了流上。
2. 当 Lambda 表达式和办法引证（method references），流（Stream）结合运用的时分会让人感觉自成一体，行云流水的感觉

先展现一段简略的流式编程：

import java.util.Random;
public class Randoms {
    public static void main(String[] args) {
        // 随机展现 5 至 20 之间不重复的整数并进行排序
        new Random(47)
                .ints(5, 20)
                .distinct()             // 使流中的整数不重复
                .limit(7)       		// 获取前 7 个元素
                .sorted()               // 排序
                .forEach(System.out::println);
    }
}

输出成果：

6
10
13
16
17
18
19

实际上函数式的编程风格是声明式（Declarative programming）的，它声明了要做什么， 而不是指明（每一步）如何做。

相同的程序，相比声明式风格，命令式（Imperative）编程的方法（指明每一步如何做），代码阅览起来会更难了解：

import java.util.Random;
import java.util.SortedSet;
import java.util.TreeSet;
public class ImperativeRandoms {
    public static void main(String[] args) {
        Random rand = new Random(47);
        SortedSet<Integer> rints = new TreeSet<>();
        while (rints.size() < 7) {
            int r = rand.nextInt(20);
            if (r < 5) continue;
            rints.add(r);
        }
        System.out.println(rints);
    }
}

输出成果：

[7, 8, 9, 11, 13, 15, 18]

所以运用流式编程的几个理由：

1. 表达力强，明晰的语义
2. 内部迭代 internal iteration （看不见迭代过程）更简略的处理并发
3. 流式懒加载的，只在肯定必要时才核算

Java 8 经过在增加接口中增加 default 关键字，经过默认办法的办法将流式 Stream 办法滑润地嵌入到现有的类中，

流操作的类型有三种：

1. 创立流：生产流
2. 修改流元素：中心操作
3. 消费流元素：终端操作，搜集流元素，一般式汇入一个调集

创立流

经过 Stream.of() 很容见的将一组元素转化为流：

import java.util.stream.Stream;
public class StreamOf {
    public static void main(String[] args) {
        // 创立流
        Stream.of(new Bubble(1), new Bubble(2), new Bubble(3))
                .forEach(System.out::println);
        Stream.of("It's ", "a ", "wonderful ", "day ", "for ", "pie!")
                .forEach(System.out::print);
        System.out.println();
        Stream.of(3.14159, 2.718, 1.618)
                .forEach(System.out::println);
    }
}

输出成果：

Bubble 1
Bubble 2
Bubble 3
It's a wonderful day for pie!
3.14159
2.718
1.618

经过 stream() 办法很简略将传统的调集转化为 Stream：

public class CollectionToStream {
    public static void main(String[] args) {
        List<Bubble> bubbles = Arrays.asList(new Bubble(1), new Bubble(2), new Bubble(3));
        System.out.println(bubbles.stream()  // 将调集转化成为流
                .mapToInt(b -> b.i)          // 获取流中一切元素，对元素进行运用操作，并产生新的目标，这里的 mapToInt 中心操作会转化成为包括整型数字的 IntStream
                .sum());                     // 算计
        HashSet<String> w = new HashSet<>(Arrays.asList("It's a wonderful day for pie!".split(" ")));
        w.stream()
                .map(x -> x + " ")
                .forEach(System.out::print);        // stream 遍历而且打印 Set 中的元素
        System.out.println();
        Map<String, Double> m = new HashMap<>();
        m.put("pi", 3.14159);
        m.put("e", 2.718);
        m.put("phi", 1.618);
        m.entrySet().stream()
                .map(e -> e.getKey() + ": " + e.getValue())
                .forEach(System.out::println);      // stream 遍历而且打印 Map 中的元素
    }
}

输出成果：

6
a pie! It's for wonderful day 
phi: 1.618
e: 2.718
pi: 3.14159

随机数流

Java 8 的 Random 类也集成流的办法，很便利的创立随机数流：

import java.util.Random;
import java.util.stream.Stream;
// 生成随机数流
public class RandomGenerators {
    public static <T> void show(Stream<T> stream) {
        stream.limit(4).forEach(System.out::println);
        System.out.println("++++++++++");
    }
    public static void main(String[] args) {
        Random rand = new Random(47);
        show(rand.ints().boxed());
        show(rand.longs().boxed());
        show(rand.doubles().boxed());
        // 操控上限和下限
        show(rand.ints(10, 20).boxed());
        show(rand.longs(50, 100).boxed());
        show(rand.doubles(20, 30).boxed());
        // 操控流大小
        show(rand.ints(2).boxed());
        show(rand.longs(2).boxed());
        show(rand.doubles(2).boxed());
        // 操控流大小和上限和下限
        show(rand.ints(3, 3, 9).boxed());
        show(rand.longs(3, 12, 22).boxed());
        show(rand.doubles(3, 11.5, 12.3).boxed());
    }
}

输出成果：

-1172028779
1717241110
-2014573909
229403722
++++++++++
2955289354441303771
3476817843704654257
-8917117694134521474
4941259272818818752
++++++++++
# ……………………

int 整型范围

Stream API 对根本数据类型生成流供给快捷的办法，例如对一段整型序列求和，展现新旧代码对比

import java.util.stream.IntStream;
public class Ranges {
    public static void main(String[] args) {
        // 传统办法
        int result = 0;
        for (int i = 0; i < 20; i++) {
            result += i;
        }
        System.out.println(result);
        // 运用流
        System.out.println(IntStream.range(0, 20).sum());
    }
}

输出成果：

190
190

generate()

Stream API 还能够结合 Supplier 函数接口来创立流，例如，创立一个随机数序列：

import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamGenerateExample {
    public static void main(String[] args) {
        Random random = new Random();
        Stream<Integer> randomNumbers = Stream.generate(random::nextInt);
        // 生成 10 个随机数放入调集中
        List<Integer> integers = randomNumbers
                .limit(10)
                .collect(Collectors.toList());
        integers.forEach(System.out::println);
    }
}

输出成果：

514000574
1771591868
600289224
-1474939200
-276604430
-876159270
509964750
-497958443
811408347
703285366

iterate()

Stream.iterate 是 Java 8 引进的 Stream API 的一部分，它接受一个种子值（seed）和一个一元函数（unary operator），然后生成一个无限的、次序的流。流中的每个元素都是经过对前一个元素运用一元函数生成的。与 Stream.generate 相似， Stream.iterate 常常用于生成一个斐波那契数列，代码示例：

import java.util.stream.Stream;
public class Fibonacci {
    int x = 1;
    Stream<Integer> numbers() {
        return Stream.iterate(0, i -> {
            int result = x + i;
            x = i;
            return result;
        });
    }
    public static void main(String[] args) {
        Fibonacci fbi = new Fibonacci();
        fbi.numbers()
                .skip(20)           // 丢弃前 20 个
                .limit(10)     // 取 10 个
                .forEach(System.out::println);
    }
}

输出成果：

6765
10946
17711
28657
46368
75025
121393
196418
317811
514229

Stream.iterate 和 Stream.generate 都是 Java 8 引进的 Stream API 的一部分，它们用于生成无限的次序流。稍不留神就简略把它们搞混，能够经过以下的办法来区分它们：

iterate：

• 它接受一个种子值（seed）和一个一元函数（unary operator）。
• 它生成的流中的每个元素都是经过对前一个元素运用一元函数生成的。
• 适用于需求生成依据前一个值的序列的场景，例如生成递加/递减序列、斐波那契数列等。

generate：

• 它接受一个 Supplier<T> 类型的参数。
• 它生成的流中的每个元素都是由供给的 Supplier 生成的。
• 适用于生成独立于前一个值的序列的场景，例如生成随机数序列、常量序列等。

Arrays

Arrays 类中的 stream() 办法用于将数组转化为 Stream。以下是运用 Arrays.stream() 办法的一些示例：

import java.util.Arrays;
public class ArraysStreamExample {
    public static void main(String[] args) {
        // IntStream
        int[] integer = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        Arrays.stream(integer)
                .filter(n -> n % 2 == 0)
                .forEach(System.out::println);
        // Stream<String>
        String[] words = {"hello", "world", "java", "stream"};
        Arrays.stream(words)
                .map(String::toUpperCase)
                .forEach(System.out::println);
        // DoubleStream
        double[] doubles = {1.0, 3.5, 7.2, 8.8, 12.0, 15.5};
        double average = Arrays.stream(doubles)
                .average()
                .orElse(0.0);
        System.out.println("Average: " + average);
    }
}

输出成果：

2
4
6
8
10
HELLO
WORLD
JAVA
STREAM
Average: 8.0

中心操作

中心操作（intermediate operations）是那些在 Stream 上履行的操作，但不会触发流的处理。它们一般回来一个新的 Stream，该 Stream 包括运用了某种操作后的元素。

以下是一些常见的中心操作：

1. filter(Predicate<T> predicate)：依据给定的谓词挑选 Stream 中的元素。
2. map(Function<T, R> mapper)：将 Stream 中的每个元素转化为另一种类型，依据给定的映射函数。
3. flatMap(Function<T, Stream<R>> mapper)：将每个元素转化为另一个 Stream，然后将一切这些流连接成一个 Stream。
4. distinct()：回来一个去重后的 Stream，其间每个元素只出现一次。
5. sorted()：回来一个按天然次序排序的 Stream。
6. sorted(Comparator<T> comparator)：依据给定的比较器回来一个排序后的 Stream。
7. peek(Consumer<T> action)：对 Stream 中的每个元素履行给定的操作，但不会改动 Stream 中的元素。一般用于调试意图。

留意：中心操作是慵懒的，也就是说，它们只在终端操作被调用时才会实际履行。例如 forEach、collect、reduce 等

跟踪和调试

Stream.peek() 是一个中心操作，它接受一个 Consumer，并答应您在流的每个元素上履行某个操作，一起保持流的元素不变。一般用于调试意图，因为它答应您查看流处理过程中的中心成果。示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Peeking {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Alice", "Bob", "Cindy", "David");
        List<String> result = names.stream()
                .filter(name -> name.length() > 3)
                .peek(name -> System.out.println("Filtered name: " + name))
                .map(String::toUpperCase)
                .peek(name -> System.out.println("Mapped name: " + name))
                .collect(Collectors.toList());
        System.out.println("Result: " + result);
    }
}

以上代码逻辑是：

1. 首要经过 filter 操作挑选出长度大于3的姓名
2. 然后，咱们运用 peek() 来打印挑选后的姓名
3. 接下来，咱们运用 map 操作将挑选后的姓名转化为大写方法
4. 然后咱们再次运用 peek() 来打印转化后的姓名
5. 最终，咱们经过 collect 操作将流中的元素搜集到一个新的 List 中，并打印成果

输出成果：

Filtered name: John
Mapped name: JOHN
Filtered name: Alice
Mapped name: ALICE
Filtered name: Cindy
Mapped name: CINDY
Filtered name: David
Mapped name: DAVID
Result: [JOHN, ALICE, CINDY, DAVID]

排序

Stream.sorted() 能够经过内置的比较器，很简略的对调集进行排序

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
public class Peeking {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Alice", "Bob", "Cindy", "David");
        List<String> result = names.stream()
                .sorted(Comparator.reverseOrder())
                .map(String::toLowerCase)
                .collect(Collectors.toList());
        System.out.println("Result: " + result);
    }
}

输出成果：

Result: [john, david, cindy, bob, alice]

过滤元素

常见的场景，Stream API 供给以下函数进行过滤：

• distinct()：消除流中重复的元素，相比创立 Set 成本低的多
• filter(Predicate)：依据 Predicate 逻辑进行过滤，剩下的元素传递给后面的流

简略看一个示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class DistinctAndFilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 1, 4, 5, 4, 6, 7, 7, 8);
        List<Integer> result = numbers.stream()
                .distinct()     // 1: 消除重复元素
                .filter(e -> e % 2 == 0)        //2: 挑选出偶数
                .collect(Collectors.toList());      //3: 将成果放入 List 中
        System.out.println(result);
    }
}

以上代码逻辑很简略：

1. 运用 distinct() 办法删除重复元素
2. 运用 filter() 办法挑选出偶数
3. 咱们经过 collect() 办法将处理后的 Stream 转化回 List

输出成果：

[2, 4, 6, 8]

操作元素

对元素的操作首要经过 map(Function) 来完成，在上面的示例代码中也有看到过，常见于以下场景：

1. 类型转化
2. 数据转化
3. 目标特点提取

相似函数 mapToInt，mapToLong，mapToDouble 操作都相同，只是成果别离为：IntStream，LongStream，DoubleStream

以下是一个简略的运用示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class MapExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        // Using map(Function) to square each number
        List<Integer> squaredNumbers = numbers.stream()
                                              .map(number -> number * number)
                                              .collect(Collectors.toList());
        System.out.println("Original list: " + numbers);
        System.out.println("Squared numbers: " + squaredNumbers);
    }
}

输出成果：

Original list: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]

兼并流

某些状况，咱们输入源的流可能是一个杂乱的多层嵌套的数据结构，咱们想在处理流数据的一起，顺便也更更改它的结构，例如把它打开为一个展平为单层数据结构，那么 flatMap() 中心函数就会派上用场：

• flatMap()：与 map() 所作的工作相同，但它将这些生成的 Stream 兼并为一个单一的 Stream

有啥用 ?

flatMap() 在函数式编程和流式处理中十分有用，因为它能够处理一些常见的数据处理问题。

1. 展平嵌套数据结构：在处理杂乱的数据结构时，咱们经常会遇到嵌套的调集，例如列表的列表、调集的调集等。flatMap() 能够将这些嵌套的数据结构展平为一个单一的流，然后简化后续的数据处理和操作。
2. 兼并多个流：在某些状况下，咱们需求将多个流兼并成一个流，以便对一切流中的数据履行相同的操作。flatMap() 能够协助咱们将这些流兼并为一个流，然后进步代码的可读性和可保护性。
3. 动态生成流：flatMap() 使咱们能够依据流中的每个元素动态生成新的流，并将这些新生成的流兼并为一个流。这对于依据流中的数据动态创立数据处理管道十分有用。
4. 更高效的操作链：在某些状况下，运用 flatMap() 能够削减对流中数据的遍历次数，然后进步操作链的效率。例如，假如咱们需求先对流中的每个元素履行映射操作，然后再履行挑选操作，咱们能够运用 flatMap() 将这两个操作组合在一起，然后削减对流的遍历次数。

展平嵌套数据结构：例如，将一个列表的列表转化为一个包括一切元素的平面列表：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class FlatMapExample {
    public static void main(String[] args) {
        List<List<Integer>> nestedList = Arrays.asList(
                Arrays.asList(1, 2, 3),
                Arrays.asList(4, 5, 6),
                Arrays.asList(7, 8, 9)
        );
        List<Integer> flatList = nestedList.stream()
                .flatMap(list -> list.stream())
                .collect(Collectors.toList());
        System.out.println("Nested list: " + nestedList);
        System.out.println("Flat list: " + flatList);
    }
}

输出成果：

Nested list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Flat list: [1, 2, 3, 4, 5, 6, 7, 8, 9]

兼并多个流：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class FlatMapExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("a", "b", "c");
        List<String> list2 = Arrays.asList("d", "e", "f");
        List<String> list3 = Arrays.asList("g", "h", "i");
        // 创立包括多个列表的流
        Stream<List<String>> listsStream = Stream.of(list1, list2, list3);
        // 运用 flatMap() 兼并多个流
        List<String> mergedList = listsStream.flatMap(list -> list.stream())
                .collect(Collectors.toList());
        System.out.println("Merged list: " + mergedList);
    }
}

说明以下上面的示例的代码：

1. 首要创立了一个包括三个列表的流（listsStream）
2. 运用 flatMap() 办法将这些列表转化为单独的流，并将这些流兼并为一个流
3. 最终，咱们运用 collect() 办法将兼并后的流转化为一个列表（mergedList）

经过运用 flatMap()，咱们能够轻松地将多个流兼并为一个流，然后简化数据处理和操作，输出成果：

Merged list: [a, b, c, d, e, f, g, h, i]

和 map() 差异

• map() 首要用于转化流中的元素，但保持流的结构不变。
• flatMap() 和 flatMap(Function) 首要用于将嵌套或多层数据结构展平为单层数据结构。

如何挑选 ?

• 假如你只需求对流中的元素履行某种操作或核算，而不需求改动流的结构，那么 map() 是一个很好的挑选
• 假如你需求将多个 Stream 兼并为一个 Stream，或许将嵌套数据结构展平为单层数据结构，那么 flatMap() 是一个更适宜的挑选

Optional 类

Optional 首要用于在流中处理一些空元素，但是它还能够运用在代码的其他地方，它带来以下一些好处，例如：

• 避免 NullPointerException：Optional 类协助您更高雅地处理可能为 null 的值
• 进步代码可读性：运用 Optional 类能够让您的代码更具表现力，更简略了解
• 更好的 API 设计：运用 Optional 类能够让您的 API 更明晰地表达预期行为，例如，回来值可能为空的状况。

流里边的 Optional

在运用 Stream 时，许多操作都会回来 Optional 目标，例如：

• findFirst(): 回来 Stream 中的第一个目标，运用 Optional 包装
• findAny(): 回来 Stream 中恣意一个目标，运用 Optional 包装
• max(): 回来 Stream 中最大的目标，运用 Optional 包装
• min(): 回来 Stream 中最小的目标，运用 Optional 包装
• average(): 回来 Stream 中一切目标的平均值，运用 OptionalDouble 包装

示例代码：

import java.util.*;
public class OptionalExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        Optional<Integer> firstNumber = numbers.stream().filter(n -> n % 2 == 0).findFirst();
        System.out.println("findFirst() example: " + firstNumber.orElse(-1));   // 输出：2
        Optional<Integer> anyNumber = numbers.stream().filter(n -> n > 2).findAny();
        System.out.println("findAny() example: " + anyNumber.orElse(-1));   // 输出：3
        Optional<Integer> maxNumber = numbers.stream().max(Comparator.naturalOrder());
        System.out.println("max() example: " + maxNumber.orElse(-1)); // 输出：9
        Optional<Integer> minNumber = numbers.stream().min(Comparator.naturalOrder());
        System.out.println("min() example: " + minNumber.orElse(-1)); // 输出：1
        OptionalDouble average = numbers.stream().mapToInt(Integer::intValue).average();
        System.out.println("average() example: " + (average.isPresent() ? average.getAsDouble() : -1)); // 输出：5.0
    }
}

输出成果：

findFirst() example: 2
findAny() example: 3
max() example: 9
min() example: 1
average() example: 5.0

示例代码还展现一些解包 Optional 的操作：

• ifPresent(Consumer)：当值存在时调用 Consumer，不然什么也不做
• orElse(otherObject)：假如值存在则直接回来，不然生成 otherObject

Optional 还供给更灵敏的 Supplier 函数式接口的调用：

• orElseGet(Supplier)：假如值存在则直接回来，不然运用 Supplier 函数生成一 个可代替目标
• orElseThrow(Supplier)：假如值存在直接回来，不然运用 Supplier 函数生成一 个异常

能够经过以下示例代码来了解：

public class OptionalExample {
    public static void main(String[] args) {
        // 生成一个空 Optional
        Optional<String> optionalValue = Optional.empty();
        // orElseGet() 示例
        String value1 = optionalValue.orElseGet(() -> "Default value");
        System.out.println("Value 1: " + value1); // 输出：Value 1: Default value
        // orElseThrow() 示例
        try {
            String value2 = optionalValue.orElseThrow(
                () -> new IllegalStateException("Value is not present")
            );
            System.out.println("Value 2: " + value2);
        } catch (RuntimeException e) {
            // 输出：Exception caught: Value is not present
            System.out.println("Exception caught: " + e.getMessage()); 
        }
    }
}

输出成果：

Value 1: Default value
Exception caught: Value is not present

创立 Optional

咱们也能够在自己的代码里边创立 Optional 目标，有以下几个静态办法能够运用：

• Optional.empty()：创立一个空的 Optional 目标。这个目标不包括任何值
• Optional.of()：运用一个非空值创立一个 Optional 目标。假如传入的值为 null，将抛出一个空指针异常
• Optional.ofNullable()：创立一个可能为 null 的 Optional 目标

示例代码：

import java.util.*;
public class OptionalExample {
    public static void main(String[] args) {
        // 生成一个空的 Optional
        Optional<String> emptyOptional = Optional.empty();
        // 生成一个不为空的 Optional
        Optional<String> optionalWithValue = Optional.of("hello world");
        // 可能为空的 Optional
        Optional<String> optionalWithValue1 = Optional.ofNullable("hello world"); // 非空值
        Optional<String> optionalWithValue2 = Optional.ofNullable(null); // 空值
    }
}

操作 Optional

创立 Optional 目标后，能够经过内置的函数对 Optional 进行更多的操作，常见的有：

• filter(Predicate): 目标的值满意给定的 Predicate，则回来该 Optional 目标
• map(Function): 运用给定的 Function 对该值进行转化，并回来一个包括转化后值的新 Optional 目标
• flatMap(Function): 运用给定的 Function 对该值进行转化，并回来一个包括转化后值的新 Optional 目标。

示例代码：

import java.util.*;
public class OptionalExample {
    public static void main(String[] args) {
        Optional<Integer> optionalValue1 = Optional.of(10);
        Optional<Integer> optionalValue2 = Optional.empty();
        // 运用 filter() 办法
        Optional<Integer> filteredValue1 = optionalValue1.filter(value -> value > 5);
        System.out.println("Filtered value 1: " + filteredValue1.orElse(-1));
        // 运用 map() 办法
        Optional<String> mappedValue1 = optionalValue1.map(value -> "Value is: " + value);
        System.out.println("Mapped value 1: " + mappedValue1.orElse("Not present"));
        // 运用 flatMap() 办法
        Optional<String> flatMappedValue1 = optionalValue2.flatMap(value -> Optional.of("Value is: " + value));
        System.out.println("FlatMapped value 1: " + flatMappedValue1.orElse("Not present"));
    }
}

输出成果：

Filtered value 1: 10
Mapped value 1: Value is: 10
FlatMapped value 1: Not present

留意：这里的 flatMap() 与 map() 办法不同，flatMap() 会改动 Optional 结构自身，map() 则不会

终端操作

终端操作（Terminal Operations）是咱们在流管道中所做的最终一件事，经过该操作获得流中的成果

数组

经过以下办法，能够轻易的搜集一个流，而且将流转为数组：

• toArray()：转化为目标数组
• toArray(generator)：转化为特定类型的数组

示例代码：

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamToArrayExample {
    public static void main(String[] args) {
        // 转化为目标数组
        Stream<String> stringStream1 = Stream.of("apple", "banana", "cherry");
        System.out.println("Stream to array 1: " + Arrays.toString(stringStream1.toArray()));
        // 转化为特定类型的数组
        Stream<String> stringStream2 = Stream.of("apple", "banana", "cherry");
        String[] stringArray = stringStream2.toArray(String[]::new);
        System.out.println("Stream to array 2: " + Arrays.toString(stringArray));
        // 对于根本类型的数组，能够运用特定的流类
        int[] array = IntStream.range(1, 6).toArray();
        System.out.println("Stream to array 3: " + Arrays.toString(array));
    }
}

输出成果：

Stream to array 1: [apple, banana, cherry]
Stream to array 2: [apple, banana, cherry]
Stream to array 3: [1, 2, 3, 4, 5]

循环

Stream 中供给 2 个循环遍历办法，用于消费流，别离如下：

• forEach()：遍历流，在并行流中不保证流的次序
• forEachOrdered()：遍历流，在并行流中保证依照流中元素的次序履行操作

咱们经过以下示例代码来证明：

import java.util.Arrays;
import java.util.List;
public class ForEachOrderedParallelExample {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("apple", "banana", "cherry", "date", "fig", "grape");
        // 次序流
        System.out.println("Sequential stream:");
        stringList.stream().forEachOrdered(System.out::println);
        // 并行流 （乱序）
        System.out.println("\nParallel stream with forEach:");
        stringList.parallelStream().forEach(System.out::println);
        // 并行流 （次序）
        System.out.println("\nParallel stream with forEachOrdered:");
        stringList.parallelStream().forEachOrdered(System.out::println);
    }
}

输出成果：

Sequential stream:
apple
banana
cherry
date
fig
grape
Parallel stream with forEach:
date
grape
fig
cherry
banana
apple
Parallel stream with forEachOrdered:
apple
banana
cherry
date
fig
grape

调集

首要用于将流中的元素搜集到不同类型的成果容器，如调集、字符串或其他数据结构。它的首要办法有：

• collect(Collector)：运用 Collector 搜集流元素到成果调集中

咱们看看如何把 Stream 搜集为常见的 List，Set，Map，还有 String ，示例代码：

public class CollectExample {
    public static void main(String[] args) {
        // 搜集到 List
        List<String> collectedList = Stream.of("apple", "banana", "orange", "grape")
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("Collected List: " + collectedList);
        // 搜集到 Set
        Set<String> collectedSet = Stream.of("apple", "banana", "orange", "grape")
                .map(String::toLowerCase)
                .collect(Collectors.toSet());
        System.out.println("Collected Set: " + collectedSet);
        // 搜集到 Map
        Map<String, Integer> map = Stream.of("apple", "banana", "orange", "grape")
                .map(String::toUpperCase)
                .collect(Collectors.toMap(s -> s, String::length));
        System.out.println("Collected Map: " + map);
        // 搜集到 String，运用逗号分隔
        String joinedString  = Stream.of("apple", "banana", "orange", "grape")
                .map(String::toUpperCase)
                .collect(Collectors.joining(","));
        System.out.println("Joined String: " + joinedString);
    }
}

输出成果：

Collected List: [APPLE, BANANA, ORANGE, GRAPE]
Collected Set: [banana, orange, apple, grape]
Collected Map: {APPLE=5, GRAPE=5, BANANA=6, ORANGE=6}
Joined String: APPLE,BANANA,ORANGE,GRAPE

说明：在这里咱们只是简略介绍了几个 Collectors 的运用示例。

实际上，它还有一些十分杂乱的操作完成，可经过查看 java.util.stream.Collectors 的 API 文档了解

组合

用于对流中的元素履行累积操作，将它们削减为一个值。reduce 的运用场景包括对流中的元素履行聚合操作，例如求和、求积、求最大值、求最小值等。Stream 里边的 reduce 办法有以下几种方法：

• reduce(BinaryOperator)：运用给定的累积器函数，对流中的元素进行累积操作。回来一个 Optional<T>
• reduce(identity, BinaryOperator)： 运用给定的初始值（identity）和累积器函数，对流中的元素进行累积操作。因而假如流为空，identity 就是成果

先看看 reduce 的示例代码：

import java.util.OptionalInt;
import java.util.stream.IntStream;
public class ReduceExample {
    public static void main(String[] args) {
        // 求和
        OptionalInt sum = IntStream.range(0, 100).reduce(Integer::sum);
        sum.ifPresent(System.out::println);
        // 求积
        OptionalInt numbers = IntStream.range(0, 100).reduce((a, b) -> a * b);
        numbers.ifPresent(System.out::println);
        // 求最大值
        OptionalInt max = IntStream.range(0, 100).reduce(Integer::max);
        max.ifPresent(System.out::println);
        // 求最小值
        OptionalInt min = IntStream.range(0, 100).reduce(Integer::min);
        min.ifPresent(System.out::println);
        // 运用给定的初始值（identity）和累积器函数，对流中的元素进行累积操作，这里回来 int 值
        int reduced = IntStream.range(0, 100).reduce(10, Integer::sum);
        System.out.println(reduced);
    }
}

输出成果：

4950
99
4960

还有一种 reduce(identity, BiFunction, BinaryOperator)：更杂乱的运用方法暂不介绍。我建议能够显式地组合 map() 和 reduce() 来更简略的表达它。

匹配

在 Stream 中的终端操作中，供给 allMatch, anyMatch, 和 noneMatch 它们用于查看流中的元素是否满意某个条件：

• allMatch(Predicate) ：流的每个元素供给给 Predicate 都回来 true ，成果回来为 true
• anyMatch(Predicate)：流中恣意一个元素供给的 Predicate 回来 true，成果回来 true
• noneMatch(Predicate)：流的每个元素供给的 Predicate 回来 false，成果回来 true

PS：以上核算都是短路操作，在匹配第一个成果时，则停止履行核算

下面是它们的运用场景和示例：

import java.util.stream.Stream;
public class MatchExample {
    public static void main(String[] args) {
        // allMatch：查看流中的一切元素是否都满意某个条件
        boolean allEven = Stream.of(1, 2, 3, 4, 5).allMatch(num -> num % 2 == 0);
        System.out.println(allEven); // 输出：false
        // anyMatch：查看流中是否存在满意某个条件的元素
        boolean anyEven = Stream.of(1, 2, 3, 4, 5).anyMatch(num -> num % 2 == 0);
        System.out.println(anyEven); // 输出：true
        // noneMatch：查看流中是否不存在满意某个条件的元素
        boolean noneMatch = Stream.of(1, 2, 3, 4, 5).noneMatch(num -> num > 10);
        System.out.println(noneMatch);  // 输出：true
    }
}

输出成果：

false
true
true

查找

在 Stream 中的终端操作中，能够依据 Predicate 获取指定的元素（在 Optional 章节介绍过），查找函数如下：

• findFirst()：查找第一个满意某个条件的元素，这在有序流中十分有用
• findAny()：在流中查找恣意一个满意某个条件的元素，这在并行流中十分有用

代码示例：

import java.util.Optional;
import java.util.stream.Stream;
public class FindExample {
    public static void main(String[] args) {
        // findFirst 示例
        Optional<Integer> first = Stream.of(1, 2, 3, 4, 5).filter(num -> num % 2 == 0).findFirst();
        first.ifPresent(System.out::println); // 输出：2
        // findAny 示例
        Optional<Integer> any = Stream.of(1, 2, 3, 4, 5, 6).filter(num -> num % 2 == 0).findAny();
        any.ifPresent(System.out::println); // 输出：2 或许 4 或许 6
    }
}

计算

最终就是一些常见对流进行计算的函数了：

• count()：计算流中的元素数量
• max(Comparator)：依据给定的比较器查找流中的最大值
• min(Comparator)：依据给定的比较器查找流中的最小值

示例代码：

// count: 流中的元素个数
System.out.println(Stream.of(1, 2, 3, 4, 5).count()); // 输出：5
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = numbers.stream().max(Comparator.naturalOrder());
Optional<Integer> min = numbers.stream().min(Comparator.naturalOrder());
// max, min: 依据给定的比较器查找流中的最大值或最小值
max.ifPresent(System.out::println); // 输出：5
min.ifPresent(System.out::println); // 输出：1

输出成果：

5
5
1

以下办法是适用于根本数据类型的特殊流，它们供给了对流中数字的根本计算信息：

• average() ：求取流元素平均值
• max() 和 min()：数值流操作无需 Comparator
• sum()：对一切流元素进行求和

代码示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// average: 求取流元素平均值
numbers.stream().mapToInt(Integer::intValue).average().ifPresent(System.out::println);  // 输出：3.0
// max: 数值流求最大值
numbers.stream().mapToInt(Integer::intValue).max().orElse(0);  // 输出：5
// min: 数值流最小值
numbers.stream().mapToInt(Integer::intValue).min().orElse(0);  // 输出：1
// sum: 数值流求和
numbers.stream().mapToInt(Integer::intValue).sum();  // 输出：15

上例操作对于 LongStream 和 DoubleStream 同样适用

总结

函数式编程 对 Java 言语的编程范式产生了深远的影响。在 Stream API 出现之前，处理调集数据一般需求运用 for 循环、条件判别和辅佐变量等。这样的代码往往冗长、杂乱，不易阅览和保护。Stream API 的引进，让咱们能以函数式编程的办法处理数据，进步了代码的简练性、可读性和可保护性。跟着函数式编程在软件开发范畴的遍及，Java 可能会引进更多的函数式编程特性，让咱们能够更便利地运用函数式编程范式编写代码。跟着函数式编程在软件开发范畴的遍及，Java 可能会引进更多的函数式编程特性，让咱们能够更便利地运用函数式编程范式编写代码。 总之，Java 其未来仍然充溢潜力。跟着技术的开展和需求的变化，Java 将不断演进，为开发者供给更好的编程体会