跳转至

Java 8 Stream API：强大的数据流处理工具

简介

Java 8 引入了 Stream API，这是一个强大的功能，它极大地简化了集合数据处理的操作。Stream API 提供了一种声明式的方式来处理集合元素，允许开发者以一种更高效、更易读的方式编写代码。通过 Stream API，我们可以将数据处理操作（如过滤、映射、归约等）组合成一个流水线，从而更方便地处理大量数据。

目录

  1. 基础概念
  2. 使用方法
    • 创建 Stream
    • 中间操作
    • 终端操作
  3. 常见实践
    • 过滤数据
    • 映射数据
    • 统计操作
    • 查找与匹配
  4. 最佳实践
    • 性能优化
    • 并行流的合理使用
    • 避免副作用
  5. 小结
  6. 参考资料

基础概念

Stream 是 Java 8 引入的一种新的抽象概念，它代表了一系列支持顺序和并行聚合操作的元素。Stream 不是数据结构，它并不存储数据，而是提供了一种在数据集合上进行各种操作的方式。Stream API 提供了丰富的操作方法，可以分为中间操作和终端操作。

中间操作

中间操作会返回一个新的 Stream，并且可以进行链式调用。这些操作是惰性求值的，即只有在终端操作被调用时，中间操作才会真正执行。常见的中间操作包括 filter、map、distinct、sorted 等。

终端操作

终端操作会触发 Stream 的处理，并返回一个结果或副作用。一旦终端操作被调用，Stream 就会被消费，不能再被使用。常见的终端操作包括 forEach、collect、reduce、count 等。

使用方法

创建 Stream

  1. 从集合创建 ```java import java.util.ArrayList; import java.util.List; import java.util.stream.Stream;

    public class StreamExample { public static void main(String[] args) { List list = new ArrayList<>(); list.add("apple"); list.add("banana"); list.add("cherry");

        // 创建顺序流
    Stream<String> stream = list.stream();

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

    } 2. **从数组创建**java import java.util.Arrays; import java.util.stream.Stream;

    public class ArrayStreamExample { public static void main(String[] args) { String[] array = {"apple", "banana", "cherry"}; Stream stream = Arrays.stream(array); } } 3. **使用 `Stream.of` 方法创建**java import java.util.stream.Stream;

    public class OfStreamExample { public static void main(String[] args) { Stream stream = Stream.of("apple", "banana", "cherry"); } } ```

中间操作

  1. 过滤数据 (filter) ```java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors;

    public class FilterExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); List evenNumbers = numbers.stream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); System.out.println(evenNumbers); } } 2. **映射数据 (`map`)**java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors;

    public class MapExample { public static void main(String[] args) { List words = Arrays.asList("apple", "banana", "cherry"); List wordLengths = words.stream() .map(String::length) .collect(Collectors.toList()); System.out.println(wordLengths); } } 3. **去重 (`distinct`)**java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors;

    public class DistinctExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4); List distinctNumbers = numbers.stream() .distinct() .collect(Collectors.toList()); System.out.println(distinctNumbers); } } 4. **排序 (`sorted`)**java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors;

    public class SortedExample { public static void main(String[] args) { List numbers = Arrays.asList(5, 2, 8, 1, 9, 3); List sortedNumbers = numbers.stream() .sorted() .collect(Collectors.toList()); System.out.println(sortedNumbers); } } ```

终端操作

  1. 遍历 (forEach) ```java import java.util.Arrays; import java.util.List;

    public class ForEachExample { public static void main(String[] args) { List fruits = Arrays.asList("apple", "banana", "cherry"); fruits.stream() .forEach(System.out::println); } } 2. **收集结果 (`collect`)**java import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.stream.Collectors;

    public class CollectExample { public static void main(String[] args) { List words = Arrays.asList("apple", "banana", "cherry"); // 收集到 List List wordList = words.stream() .collect(Collectors.toList());

        // 收集到 Set
    Set<String> wordSet = words.stream()
          .collect(Collectors.toSet());

    // 按长度分组
    Map<Integer, List<String>> wordMap = words.stream()
          .collect(Collectors.groupingBy(String::length));
}

    } 3. **归约 (`reduce`)**java import java.util.Arrays; import java.util.List;

    public class ReduceExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); int sum = numbers.stream() .reduce(0, (a, b) -> a + b); System.out.println(sum); } } 4. **统计操作 (`count`, `min`, `max`)**java import java.util.Arrays; import java.util.List;

    public class StatisticExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); long count = numbers.stream() .count(); Integer min = numbers.stream() .min(Integer::compareTo) .orElse(0); Integer max = numbers.stream() .max(Integer::compareTo) .orElse(0); System.out.println("Count: " + count); System.out.println("Min: " + min); System.out.println("Max: " + max); } } ```

常见实践

过滤数据

在处理集合数据时，经常需要根据某些条件过滤出符合要求的元素。例如，从一个员工列表中筛选出年龄大于 30 岁的员工：

import java.util.ArrayList;
import java.util.List;

class Employee {
    private String name;
    private int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class EmployeeFilterExample {
    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("Alice", 25));
        employees.add(new Employee("Bob", 32));
        employees.add(new Employee("Charlie", 35));

        List<Employee> filteredEmployees = employees.stream()
              .filter(e -> e.getAge() > 30)
              .collect(Collectors.toList());
    }
}

映射数据

将一种类型的数据转换为另一种类型是常见的需求。比如，将一个字符串列表中的每个字符串转换为大写形式：

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

public class StringMapExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        List<String> upperCaseWords = words.stream()
              .map(String::toUpperCase)
              .collect(Collectors.toList());
        System.out.println(upperCaseWords);
    }
}

统计操作

对集合中的数据进行统计分析，如计算总和、平均值、最大值、最小值等。例如，计算一个整数列表的平均值：

import java.util.Arrays;
import java.util.List;

public class AverageExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        double average = numbers.stream()
              .mapToInt(Integer::intValue)
              .average()
              .orElse(0);
        System.out.println("Average: " + average);
    }
}

查找与匹配

在集合中查找特定元素或判断集合中是否存在满足条件的元素。例如，判断一个列表中是否存在某个字符串：

import java.util.Arrays;
import java.util.List;

public class AnyMatchExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        boolean exists = words.stream()
              .anyMatch("banana"::equals);
        System.out.println("Exists: " + exists);
    }
}

最佳实践

性能优化

  1. 避免不必要的中间操作：尽量减少链式调用中的中间操作数量，因为每个中间操作都会增加处理的复杂度。
  2. 使用合适的数据结构：选择合适的数据结构可以提高 Stream 操作的性能。例如，使用 HashSet 进行去重操作会比 List 更高效。

并行流的合理使用

  1. 数据量足够大：并行流适用于处理大量数据的场景。如果数据量较小，并行流的开销可能会超过其带来的性能提升。
  2. 无状态操作：并行流中的操作应该是无状态的，即操作的结果不依赖于之前的操作状态。例如，filter、map 等操作是无状态的，而 reduce 操作如果依赖于之前的结果则需要谨慎使用。

避免副作用

Stream API 设计的初衷是为了支持函数式编程，因此应该避免在 Stream 操作中产生副作用。例如，不要在 forEach 操作中修改外部变量，因为并行流可能会导致不可预测的结果。

小结

Java 8 的 Stream API 为集合数据处理提供了一种强大而简洁的方式。通过理解基础概念、掌握使用方法以及遵循最佳实践，开发者可以更高效地编写代码，处理各种数据操作需求。Stream API 的引入不仅提升了代码的可读性和可维护性，还在性能优化方面提供了更多的可能性。

参考资料

  1. Oracle Java Documentation - Stream API
  2. Effective Java, Third Edition - Joshua Bloch
  3. Java 8 in Action - Raoul-Gabriel Urma, Mario Fusco, Alan Mycroft