Java 流 (Stream) 详解

欢迎来到 Java 流 (Stream) 深入讲解，在处理大量数据时，Java 流 (Stream) 可以帮助你更简洁、高效地处理数据。

1. Stream API 简介

• 概念: Stream 是一个数据处理管道，可以将数据进行过滤、排序、转换等操作。

• 优势:

  • 简洁: 使用流可以写出更简洁的代码。

  • 高效: 流可以并行处理数据，提高性能。

  • 可读性: 流的代码更易于理解。

2. 创建 Stream

• 从集合创建:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
Stream<String> stream = names.stream();

• 从数组创建:

String[] names = {"Alice", "Bob", "Charlie", "David"};
Stream<String> stream = Arrays.stream(names);

• 使用 Stream.of():

Stream<String> stream = Stream.of("Alice", "Bob", "Charlie", "David");

3. Stream 操作

3.1 中间操作: 不产生结果，返回新的 Stream。

• filter: 过滤元素。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> longNames = names.stream()
    .filter(name -> name.length() > 4)
    .collect(Collectors.toList());

• limit: 获取前 n 个元素。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> firstTwoNames = names.stream()
    .limit(2)
    .collect(Collectors.toList());

• skip: 跳过前 n 个元素。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> lastTwoNames = names.stream()
    .skip(2)
    .collect(Collectors.toList());

• distinct: 去重。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Alice");
List<String> uniqueNames = names.stream()
    .distinct()
    .collect(Collectors.toList());

• concat: 合并两个流。

Stream<String> stream1 = Stream.of("Alice", "Bob");
Stream<String> stream2 = Stream.of("Charlie", "David");
Stream<String> combinedStream = Stream.concat(stream1, stream2);

• map: 转换元素。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<Integer> lengths = names.stream()
    .map(String::length)
    .collect(Collectors.toList());

3.2 终结操作: 产生结果。

• forEach: 遍历元素。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
names.stream().forEach(System.out::println);

• count: 统计元素个数。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
long count = names.stream().count();

• toArray: 收集元素到数组。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
String[] namesArray = names.stream().toArray(String[]::new);

• collect: 收集元素到集合。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> upperCaseNames = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

4. Stream 的练习 

示例 1: 处理和筛选数字列表

这个示例展示了如何使用流的中间方法（如 filter 和 map）和终结方法（如 collect 和 forEach）来处理和筛选数字列表。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamDemo1 {
    public static void main(String[] args) {
        // 创建一个整数列表
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用流的中间方法和终结方法处理数据
        List<Integer> result = numbers.stream()  // 创建流
            .filter(n -> n % 2 == 0)             // 中间方法: 过滤出偶数
            .map(n -> n * n)                    // 中间方法: 计算每个偶数的平方
            .collect(Collectors.toList());      // 终结方法: 将结果收集到列表中

        // 打印结果
        System.out.println("偶数的平方: " + result);

        // 使用流的终结方法直接输出
        System.out.println("偶数的平方（直接输出）:");
        numbers.stream()
            .filter(n -> n % 2 == 0)             // 中间方法: 过滤出偶数
            .map(n -> n * n)                    // 中间方法: 计算每个偶数的平方
            .forEach(System.out::println);     // 终结方法: 直接输出每个平方
    }
}

解释：

• numbers.stream()：将列表转换为流。
• filter(n -> n % 2 == 0)：中间方法，筛选出偶数。
• map(n -> n * n)：中间方法，将每个偶数映射为它的平方。
• collect(Collectors.toList())：终结方法，将处理结果收集到新的列表中。
• forEach(System.out::println)：终结方法，直接打印每个平方值。

 

示例 2: 处理员工数据

这个示例展示了如何使用流的中间方法（如 sorted 和 distinct）和终结方法（如 count 和 toList）来处理员工数据列表。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamDemo2 {
    public static void main(String[] args) {
        // 创建一个员工数据列表
        List<String> employees = Arrays.asList(
            "Alice", "Bob", "Charlie", "Alice", "David", "Bob", "Eve");

        // 使用流的中间方法和终结方法处理数据
        long uniqueCount = employees.stream()       // 创建流
            .distinct()                           // 中间方法: 去重
            .sorted()                             // 中间方法: 排序
            .peek(System.out::println)            // 中间方法: 打印每个元素（调试用）
            .count();                             // 终结方法: 计算去重后元素的数量

        // 打印去重后的员工名称
        System.out.println("去重后的员工名称:");
        List<String> sortedUniqueEmployees = employees.stream()
            .distinct()                           // 中间方法: 去重
            .sorted()                             // 中间方法: 排序
            .collect(Collectors.toList());        // 终结方法: 将结果收集到列表中

        // 打印结果
        System.out.println(sortedUniqueEmployees);
        System.out.println("去重后的员工数量: " + uniqueCount);
    }
}

解释：

• employees.stream()：将列表转换为流。
• distinct()：中间方法，去除重复的元素。
• sorted()：中间方法，对元素进行排序。
• peek(System.out::println)：中间方法，用于调试，打印流中的每个元素。
• count()：终结方法，计算流中元素的数量。
• collect(Collectors.toList())：终结方法，将处理结果收集到新的列表中。

结语：Java 流可以帮助你更简洁、高效地处理数据，以上就是关于其的讲解，希望对各位看官有所帮助，感谢各位看官的观看，下期见，谢谢~