Java Stream流工具的常见用法_java list stream of-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_39144436/article/details/144313819

Java 8 引入了 Stream API，这是一个功能强大且灵活的工具，用于处理集合（如 List、Set 等）中的元素。Stream API 采用声明式编程范式，使得代码更加简洁、可读，并且易于并行处理。相信大家在工作中应该已经广泛的使用这个工具了。

一、什么是Stream流

Stream 是一种序列化的数据流，它不同于传统的集合（如 List 或 Set）。Stream 不存储数据，而是通过管道（pipeline）对数据源（如集合、数组、I/O 频道等）进行操作。Stream 操作通常分为两种类型：

中间操作：返回一个新的 Stream，可以链接多个中间操作。这些操作是延迟执行的，直到终止操作触发时才执行。
终止操作：生成一个最终结果，如集合、单个值或无返回值（如 forEach）。终止操作会触发所有延迟的中间操作，并关闭流。

二、Stream流的常用操作

2.1 创建 Stream

可以通过多种方式创建 Stream：

通过集合：

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

// 并行流
Stream<String> parallelStream = list.parallelStream();

通过数组：

String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

通过静态工厂方法：

Stream<String> stream = Stream.of("a", "b", "c");

无限流：

Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2); // 0, 2, 4, 6, ...
Stream<Double> randomNumbers = Stream.generate(Math::random);

2.2 中间操作

filter：过滤符合条件的元素

stream.filter(s -> s.startsWith("A"));

map：对每个元素应用函数，生成新的元素

stream.map(String::toUpperCase);

sorted：对流中的元素进行排序

stream.sorted();

// 根据自定义比较器排序
stream.sorted(Comparator.reverseOrder());

distinct：去重

stream.distinct();

limit 和 skip：截断流

stream.limit(5); // 只取前5个元素
stream.skip(2);  // 跳过前2个元素

flatMap：将每个元素转换成一个流，然后将所有流连接成一个流

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d")
);
Stream<String> flatStream = listOfLists.stream()
    .flatMap(List::stream);

2.3 终止操作

collect：将流转换为集合或其他结构

List<String> collected = stream.collect(Collectors.toList());
Set<String> collectedSet = stream.collect(Collectors.toSet());

forEach：对每个元素执行操作

stream.forEach(System.out::println);

reduce：通过某种方式将流中的元素合并成一个结果

Optional<String> concatenated = stream.reduce((a, b) -> a + b);

count、min、max、anyMatch 等

long count = stream.count();
Optional<String> min = stream.min(String::compareTo);
boolean anyMatch = stream.anyMatch(s -> s.startsWith("A"));

三、示例代码

下面通过一个具体的示例来展示如何使用 Stream API。

3.1 基础操作

假设有一个学生类：

class Student {
    private String name;
    private int age;
    private double grade;
    
    // 构造方法、getter 和 toString 方法
    public Student(String name, int age, double grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
    public double getGrade() { return grade; }
    
    @Override
    public String toString() {
        return String.format("Student{name='%s', age=%d, grade=%.2f}", name, age, grade);
    }
}

创建一个学生列表，并使用 Stream API 进行操作：

import java.util.*;
import java.util.stream.*;

public class StreamExample {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("Alice", 20, 85.5),
            new Student("Bob", 22, 90.0),
            new Student("Charlie", 23, 70.0),
            new Student("David", 21, 60.5),
            new Student("Eve", 20, 95.0),
            new Student("Frank", 22, 88.0)
        );
        
        // 1. 过滤成绩大于80的学生
        List<Student> highGradeStudents = students.stream()
            .filter(s -> s.getGrade() > 80)
            .collect(Collectors.toList());
        System.out.println("成绩大于80的学生: " + highGradeStudents);
        
        // 2. 获取所有学生的名字，并转换为大写
        List<String> upperNames = students.stream()
            .map(Student::getName)
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        System.out.println("所有学生的大写名字: " + upperNames);
        
        // 3. 找出年龄最大的学生
        Optional<Student> oldestStudent = students.stream()
            .max(Comparator.comparingInt(Student::getAge));
        oldestStudent.ifPresent(s -> System.out.println("年龄最大的学生: " + s));
        
        // 4. 计算所有学生的平均成绩
        double averageGrade = students.stream()
            .mapToDouble(Student::getGrade)
            .average()
            .orElse(0.0);
        System.out.println("平均成绩: " + averageGrade);
        
        // 5. 分组学生按年龄
        Map<Integer, List<Student>> studentsByAge = students.stream()
            .collect(Collectors.groupingBy(Student::getAge));
        System.out.println("按年龄分组的学生: " + studentsByAge);
        
        // 6. 检查是否所有学生的成绩都大于50
        boolean allAbove50 = students.stream()
            .allMatch(s -> s.getGrade() > 50);
        System.out.println("所有学生的成绩都大于50: " + allAbove50);
        
        // 7. 提取成绩最高的前3名学生
        List<Student> top3Students = students.stream()
            .sorted(Comparator.comparingDouble(Student::getGrade).reversed())
            .limit(3)
            .collect(Collectors.toList());
        System.out.println("成绩最高的前3名学生: " + top3Students);
    }
}

输出结果：

成绩大于80的学生: [Student{name='Alice', age=20, grade=85.50}, Student{name='Bob', age=22, grade=90.00}, Student{name='Eve', age=20, grade=95.00}, Student{name='Frank', age=22, grade=88.00}]
所有学生的大写名字: [ALICE, BOB, CHARLIE, DAVID, EVE, FRANK]
年龄最大的学生: Student{name='Charlie', age=23, grade=70.00}
平均成绩: 81.33333333333333
按年龄分组的学生: {20=[Student{name='Alice', age=20, grade=85.50}, Student{name='Eve', age=20, grade=95.00}], 21=[Student{name='David', age=21, grade=60.50}], 22=[Student{name='Bob', age=22, grade=90.00}, Student{name='Frank', age=22, grade=88.00}], 23=[Student{name='Charlie', age=23, grade=70.00}]}
所有学生的成绩都大于50: true
成绩最高的前3名学生: [Student{name='Eve', age=20, grade=95.00}, Student{name='Bob', age=22, grade=90.00}, Student{name='Frank', age=22, grade=88.00}]

3.2 处理无限流

Stream API 支持创建和操作无限流，常用于生成无限序列。需要注意的是，使用无限流时必须确保最终会有一个终止操作，否则程序会无限执行下去。

import java.util.stream.*;

public class InfiniteStreamExample {
    public static void main(String[] args) {
        // 生成一个从1开始的无限整数流
        Stream<Integer> integerStream = Stream.iterate(1, n -> n + 1);
        
        // 取前10个偶数并打印
        integerStream
            .filter(n -> n % 2 == 0)
            .limit(10)
            .forEach(System.out::println);
        
        // 生成一个无限随机数流，取前5个大于0.9的数
        Stream<Double> randomStream = Stream.generate(Math::random);
        randomStream
            .filter(d -> d > 0.9)
            .limit(5)
            .forEach(System.out::println);
    }
}

输出示例：

2
4
6
8
10
12
14
16
18
20
0.918273645...
0.956789123...
0.923456789...
0.987654321...
0.912345678...

3.3 并行流

Stream API 支持并行处理，可以通过 parallelStream() 或调用 parallel() 方法将流转为并行流。并行流可利用多核处理器加速数据处理，但并非所有场景都适用，需谨慎使用。

import java.util.*;
import java.util.stream.*;

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = IntStream.rangeClosed(1, 1000000).boxed().collect(Collectors.toList());
        
        // 顺序流计算平方和
        long startTime = System.currentTimeMillis();
        long sum = numbers.stream()
            .map(n -> n * n)
            .reduce(0L, Long::sum);
        long endTime = System.currentTimeMillis();
        System.out.println("顺序流计算平方和: " + sum + ", 时间: " + (endTime - startTime) + "ms");
        
        // 并行流计算平方和
        startTime = System.currentTimeMillis();
        long parallelSum = numbers.parallelStream()
            .map(n -> n * n)
            .reduce(0L, Long::sum);
        endTime = System.currentTimeMillis();
        System.out.println("并行流计算平方和: " + parallelSum + ", 时间: " + (endTime - startTime) + "ms");
    }
}

输出示例：

顺序流计算平方和: 333333833333500000, 时间: 150ms
并行流计算平方和: 333333833333500000, 时间: 80ms

注意：实际执行时间取决于机器性能和当前系统负载。

四、注意事项

流不能重复使用：Stream 是一次性的，执行终止操作后，不能再次使用同一个流。
中间操作顺序：部分中间操作会影响执行顺序，如 sorted、limit 等，应合理安排操作顺序以优化性能。
并行流的线程安全：在并行流中使用的操作应是线程安全的，避免引发并发问题。

Java 8 的 Stream API 为集合操作带来了革命性的变化，通过声明式、流水线式的编程方式，使得代码更加简洁、易读且易于维护。掌握 Stream API 的使用，对于编写高效、现代化的 Java 代码至关重要。

建议大家在实际开发中多加练习，灵活运用 Stream API 的各种操作，以充分发挥其强大功能。

文章同步更新在个人微信公众号：IT路旅记
感兴趣的伙伴可以关注订阅，方便浏览。