Java基础 - Stream 流：构建流的多种方式

Stream 流是 Java 8 中引入的一种新的抽象，它可以让你以声明式的方式处理数据集合。Stream 流不是数据结构，而是一种对数据源进行各种操作的视图。Stream 流可以支持串行或并行的执行，提高了代码的可读性和性能。

要使用 Stream 流，首先你需要有一个数据源，比如一个数组、一个集合、一个文件、一个生成器等。然后你可以通过多种方式构建一个 Stream 流对象，对数据源进行转换。最后，你可以对 Stream 流进行终端操作，得到一个结果或者产生一个副作用。

我们将探索构建 Stream 流的多种方式，包括：

• 从数组或集合构建 Stream 流
• 从文件或 I/O 构建 Stream 流
• 从函数生成 Stream 流
• 从其他 Stream 流构建 Stream 流

从数组或集合构建 Stream 流

如果你有一个数组或一个集合，你可以使用 Arrays.stream() 或 Collection.stream() 方法来构建一个 Stream 流对象。例如：

// 从数组构建 Stream 流
String[] names = {"Alice", "Bob", "Charlie", "David"};
Stream<String> nameStream = Arrays.stream(names);

// 从集合构建 Stream 流
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
Stream<Integer> numberStream = numbers.stream();

你也可以使用 Stream.of() 方法来构建一个 Stream 流对象，它可以接受任意数量的参数，或者一个数组。例如：

// 从多个参数构建 Stream 流
Stream<String> colorStream = Stream.of("red", "green", "blue");

// 从一个数组构建 Stream 流
Double[] scores = {98.5, 85.4, 76.3, 92.1};
Stream<Double> scoreStream = Stream.of(scores);

从文件或 I/O 构建 Stream 流

如果你有一个文件或一个 I/O 资源，你可以使用 Files.lines() 或 BufferedReader.lines() 方法来构建一个 Stream 流对象，它们会返回一个由文件或 I/O 资源的每一行组成的 Stream 流对象。例如：

// 从文件构建 Stream 流
Path path = Paths.get("data.txt");
try (Stream<String> lineStream = Files.lines(path)) {
    // 对每一行进行操作
    lineStream.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

// 从 I/O 资源构建 Stream 流
try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
    // 从标准输入读取每一行
    Stream<String> inputStream = reader.lines();
    // 对每一行进行操作
    inputStream.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

从函数生成 Stream 流

如果你没有一个现成的数据源，你可以使用 Stream.generate() 或 Stream.iterate() 方法来构建一个 Stream 流对象，它们会根据一个函数来生成一个无限的 Stream 流对象。你可以使用 limit() 方法来限制 Stream 流的大小。例如：

// 使用 generate() 方法构建 Stream 流
// 生成一个随机数的 Stream 流
Stream<Double> randomStream = Stream.generate(Math::random);
// 限制 Stream 流的大小为 10
randomStream.limit(10).forEach(System.out::println);

// 使用 iterate() 方法构建 Stream 流
// 生成一个斐波那契数列的 Stream 流
Stream<Integer> fibonacciStream = Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
        .map(t -> t[0]);
// 限制 Stream 流的大小为 10
fibonacciStream.limit(10).forEach(System.out::println);

从其他 Stream 流构建 Stream 流

如果你已经有一个 Stream 流对象，你可以使用一些中间操作来构建一个新的 Stream 流对象，对原来的 Stream 流进行转换或过滤。例如：

// 从一个 Stream 流构建另一个 Stream 流
Stream<String> animalStream = Stream.of("cat", "dog", "elephant", "fox", "giraffe");

// 使用 filter() 方法过滤出长度为 3 的字符串
Stream<String> filteredStream = animalStream.filter(s -> s.length() == 3);
// 输出 [cat, dog, fox]
filteredStream.forEach(System.out::println);

// 使用 map() 方法将字符串转换为大写
Stream<String> mappedStream = animalStream.map(String::toUpperCase);
// 输出 [CAT, DOG, ELEPHANT, FOX, GIRAFFE]
mappedStream.forEach(System.out::println);

// 使用 flatMap() 方法将多个 Stream 流合并为一个
Stream<String> fruitStream = Stream.of("apple", "banana", "cherry");
Stream<String> vegetableStream = Stream.of("carrot", "lettuce", "tomato");
Stream<String> foodStream = Stream.of(fruitStream, vegetableStream).flatMap(s -> s);
// 输出 [apple, banana, cherry, carrot, lettuce, tomato]
foodStream.forEach(System.out::println);

以上就是构建 Stream 流的多种方式的介绍，希望对你有所帮助。
​