Stream API详解 - 《Java基础教程》 - 严富坤的知识库专栏(yanfukun.com)

背景与初衷
优势和劣势
- 优势
- 劣势
适用场景
- 业务场景
- 技术场景
Stream API 的组成部分和关键点
Stream API 的底层原理和实现
Stream API 与其他同类技术的对比
- 与传统集合操作的对比
- 与 Guava 的 FluentIterable 的对比
Stream API 高级用法
常见的 Stream API 用法
总结

Java 8 引入了 Stream API，这是 Java 语言的一项强大特性，旨在提高集合类（如 List、Set 和 Map）的处理效率。Stream API 允许开发者以声明式的方式操作数据集合，简化了代码编写，并且通常能提高性能。本文将深入探讨 Java Stream API 的各个方面，介绍其背景、优势、适用场景、组成部分、底层原理以及与其他同类技术的对比，结合大量示例代码进行详细说明。

背景与初衷

在 Java 8 之前，处理集合数据通常需要编写大量的循环代码，这不仅繁琐，而且容易出错。特别是涉及到复杂的数据操作时，如过滤、排序、映射等，更是容易出现冗长且难以维护的代码。为了解决这些问题，Java 8 引入了 Stream API，允许开发者以声明式的方式处理数据集合，使代码更简洁、可读性更高，并且便于并行化处理。

优势和劣势

优势

简洁性：使用 Stream API 可以大大减少代码量，避免繁琐的循环和条件判断。
可读性：声明式编程风格使得代码更直观、更容易理解和维护。
可组合性：Stream API 提供了丰富的操作方法，可以灵活地组合使用，满足各种数据处理需求。
并行处理：Stream API 支持并行流处理，充分利用多核处理器的优势，提高性能。

劣势

学习曲线：对于不熟悉函数式编程的开发者来说，学习和掌握 Stream API 需要一定时间。
调试困难：由于 Stream API 采用链式调用的方式，调试代码时不如传统的循环和条件判断代码直观。
性能开销：在某些情况下，Stream API 的性能可能不如手动优化的循环代码，特别是在处理简单的场景时。

适用场景

业务场景

数据过滤：在电商平台中，过滤符合特定条件的商品列表。
数据转换：在社交网络中，将用户的数据从一种格式转换为另一种格式。
数据聚合：在金融系统中，计算用户的总交易金额或平均交易金额。

技术场景

日志处理：使用 Stream API 处理和分析日志数据，提取有用的信息。
文件处理：读取和处理大文件中的数据，例如统计字数或筛选特定的行。
并行计算：利用并行流进行大数据集的计算，提高处理效率。

Stream API 的组成部分和关键点

创建 Stream

Stream API 提供了多种创建流的方法，包括从集合、数组、生成器和文件等创建流。

从集合创建流

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class StreamFromCollection {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        Stream<String> stream = list.stream();
        stream.forEach(System.out::println);
    }
}

从数组创建流

import java.util.stream.Stream;
public class StreamFromArray {
    public static void main(String[] args) {
        String[] array = {"apple", "banana", "cherry"};
        Stream<String> stream = Stream.of(array);
        stream.forEach(System.out::println);
    }
}

使用生成器创建流

import java.util.stream.Stream;
public class StreamFromGenerator {
    public static void main(String[] args) {
        Stream<Double> stream = Stream.generate(Math::random).limit(5);
        stream.forEach(System.out::println);
    }
}

从文件创建流

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;
public class StreamFromFile {
    public static void main(String[] args) {
        try (Stream<String> stream = Files.lines(Paths.get("file.txt"))) {
            stream.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

中间操作

中间操作用于转换流的元素，通常会返回一个新的流。中间操作是惰性的，只有在终端操作执行时才会被处理。

`filter`

filter 方法用于过滤符合条件的元素。

import java.util.Arrays;
import java.util.List;
public class StreamFilter {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
        list.stream()
            .filter(s -> s.startsWith("b"))
            .forEach(System.out::println);
    }
}

`map`

map 方法用于将流的每个元素映射到另一个元素。

import java.util.Arrays;
import java.util.List;
public class StreamMap {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
            .map(String::toUpperCase)
            .forEach(System.out::println);
    }
}

`flatMap`

flatMap 方法用于将每个元素转换为流，并将多个流合并为一个流。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamFlatMap {
    public static void main(String[] args) {
        List<List<String>> listOfLists = Arrays.asList(
            Arrays.asList("a", "b", "c"),
            Arrays.asList("d", "e", "f"),
            Arrays.asList("g", "h", "i")
        );
        List<String> list = listOfLists.stream()
            .flatMap(List::stream)
            .collect(Collectors.toList());
        System.out.println(list);
    }
}

`sorted`

sorted 方法用于对流的元素进行排序。

import java.util.Arrays;
import java.util.List;
public class StreamSorted {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("banana", "apple", "cherry");
        list.stream()
            .sorted()
            .forEach(System.out::println);
    }
}

`distinct`

distinct 方法用于去除流中的重复元素。

import java.util.Arrays;
import java.util.List;
public class StreamDistinct {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "apple", "cherry");
        list.stream()
            .distinct()
            .forEach(System.out::println);
    }
}

`peek`

peek 方法用于在流的每个元素上执行操作，并返回一个新的流。通常用于调试。

import java.util.Arrays;
import java.util.List;
public class StreamPeek {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
            .peek(s -> System.out.println("Processing: " + s))
            .map(String::toUpperCase)
            .forEach(System.out::println);
    }
}

终端操作

终端操作用于触发流的计算，通常会返回一个结果或副作用，并结束流的处理。

`forEach`

forEach 方法用于对流的每个元素执行操作。

import java.util.Arrays;
import java.util.List;
public class StreamForEach {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
            .forEach(System.out::println);
    }
}

`collect`

collect 方法用于将流的元素收集到集合或其他容器中。

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class StreamCollect {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        Set<String> set = list.stream()
            .collect(Collectors.toSet());
        System.out.println(set);
    }
}

`toArray`

toArray 方法用于将流的元素收集到数组中。

import java.util.Arrays;
import java.util.List;
public class StreamToArray {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        String[] array = list.stream()
            .toArray(String[]::new);
        System.out.println(Arrays.toString(array));
    }
}

`reduce`

reduce 方法用于将流的元素组合成一个结果。

import java.util.Arrays;
import java.util.List;
public class StreamReduce {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        int sum =
 list.stream()
            .reduce(0, Integer::sum);
        System.out.println("Sum: " + sum);
    }
}

`findFirst`

findFirst 方法用于返回流的第一个元素（如果存在）。

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class StreamFindFirst {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        Optional<String> first = list.stream()
            .findFirst();
        first.ifPresent(System.out::println);
    }
}

`findAny`

findAny 方法用于返回流的任意一个元素（如果存在）。

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class StreamFindAny {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        Optional<String> any = list.stream()
            .findAny();
        any.ifPresent(System.out::println);
    }
}

`count`

count 方法用于返回流中元素的数量。

import java.util.Arrays;
import java.util.List;
public class StreamCount {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        long count = list.stream()
            .count();
        System.out.println("Count: " + count);
    }
}

`anyMatch`

anyMatch 方法用于检查是否至少有一个元素符合给定的条件。

import java.util.Arrays;
import java.util.List;
public class StreamAnyMatch {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        boolean hasBanana = list.stream()
            .anyMatch(s -> s.equals("banana"));
        System.out.println("Has banana: " + hasBanana);
    }
}

`allMatch`

allMatch 方法用于检查是否所有元素都符合给定的条件。

import java.util.Arrays;
import java.util.List;
public class StreamAllMatch {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        boolean allHaveA = list.stream()
            .allMatch(s -> s.contains("a"));
        System.out.println("All contain 'a': " + allHaveA);
    }
}

`noneMatch`

noneMatch 方法用于检查是否没有元素符合给定的条件。

import java.util.Arrays;
import java.util.List;
public class StreamNoneMatch {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        boolean noneHaveZ = list.stream()
            .noneMatch(s -> s.contains("z"));
        System.out.println("None contain 'z': " + noneHaveZ);
    }
}

Stream API 的底层原理和实现

惰性求值和终端操作

Stream API 的核心思想是惰性求值，即中间操作（如 filter、map 等）不会立即执行，只有在终端操作（如 forEach、collect 等）调用时才会触发实际的计算。这种设计使得 Stream API 能够进行多次优化，提高性能。

import java.util.Arrays;
import java.util.List;
public class LazyEvaluation {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
            .filter(s -> {
                System.out.println("Filtering: " + s);
                return s.startsWith("a");
            })
            .map(s -> {
                System.out.println("Mapping: " + s);
                return s.toUpperCase();
            })
            .forEach(s -> System.out.println("Final: " + s));
    }
}

流的并行处理

Stream API 支持并行流处理，通过调用 parallelStream 方法或 parallel 方法，可以轻松地将串行流转换为并行流，从而利用多核处理器的优势，提高性能。

import java.util.Arrays;
import java.util.List;
public class ParallelStream {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.parallelStream()
            .filter(s -> s.startsWith("a"))
            .map(String::toUpperCase)
            .forEach(System.out::println);
    }
}

Spliterator

Spliterator 是 Iterator 的增强版，专为并行流设计，能够有效地分割数据源，并行处理数据。

import java.util.Arrays;
import java.util.List;
import java.util.Spliterator;
public class SpliteratorExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
        Spliterator<String> spliterator1 = list.spliterator();
        Spliterator<String> spliterator2 = spliterator1.trySplit();
        System.out.println("Spliterator 1:");
        spliterator1.forEachRemaining(System.out::println);
        System.out.println("Spliterator 2:");
        spliterator2.forEachRemaining(System.out::println);
    }
}

Stream API 与其他同类技术的对比

与传统集合操作的对比

传统集合操作通常需要使用循环和条件判断，代码冗长且不易维护。而 Stream API 提供了声明式的编程风格，使代码更加简洁和易读。

传统集合操作示例：

import java.util.ArrayList;
import java.util.List;
public class TraditionalCollectionOperations {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");
        List<String> filteredList = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("a")) {
                filteredList.add(s.toUpperCase());
            }
        }
        for (String s : filteredList) {
            System.out.println(s);
        }
    }
}

Stream API 操作示例：

import java.util.Arrays;
import java.util.List;
public class StreamOperations {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
            .filter(s -> s.startsWith("a"))
            .map(String::toUpperCase)
            .forEach(System.out::println);
    }
}

与 Guava 的 FluentIterable 的对比

Guava 的 FluentIterable 提供了类似于 Stream API 的功能，但 Stream API 更加灵活和强大，且完全集成在 Java 标准库中。

Guava FluentIterable 示例：

import com.google.common.collect.FluentIterable;
import java.util.Arrays;
import java.util.List;
public class FluentIterableExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        FluentIterable.from(list)
            .filter(s -> s.startsWith("a"))
            .transform(String::toUpperCase)
            .forEach(System.out::println);
    }
}

Stream API 操作示例：

import java.util.Arrays;
import java.util.List;
public class StreamOperations {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.stream()
            .filter(s -> s.startsWith("a"))
            .map(String::toUpperCase)
            .forEach(System.out::println);
    }
}

Stream API 高级用法

无限流

Stream API 支持创建无限流，常用于生成无限的数据序列。可以使用 Stream.generate 或 Stream.iterate 方法创建无限流，并通过 limit 方法限制流的大小。

import java.util.stream.Stream;
public class InfiniteStream {
    public static void main(String[] args) {
        Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1);
        infiniteStream.limit(10)
            .forEach(System.out::println);
    }
}

自定义收集器

Stream API 提供了 Collector 接口，允许开发者创建自定义的收集器，以实现复杂的收集操作。

import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class CustomCollector {
    public static void main(String[] args) {
        Collector<String, Set<String>, Set<String>> toCustomSet =
            Collector.of(
                HashSet::new,
                Set::add,
                (left, right) -> { left.addAll(right); return left; }
            );
        Set<String> set = Stream.of("apple", "banana", "cherry")
            .collect(toCustomSet);
        System.out.println(set);
    }
}

并行流的最佳实践

并行流可以提高处理性能，但也需要注意一些最佳实践，以避免潜在的问题。

避免修改共享状态：并行流中不应该修改共享

的可变数据，以避免并发问题。

选择合适的数据源：某些数据源（如 ArrayList 和 HashMap）在并行流中表现更好。
监控性能：并行流并不总是比串行流快，特别是在小数据集或简单操作时，需要通过性能测试来确定是否使用并行流。

import java.util.Arrays;
import java.util.List;
public class ParallelStreamBestPractices {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry", "fig", "grape");
        // 串行流
        long startTime = System.nanoTime();
        list.stream()
            .filter(s -> s.length() > 4)
            .forEach(System.out::println);
        long endTime = System.nanoTime();
        System.out.println("Sequential stream time: " + (endTime - startTime));
        // 并行流
        startTime = System.nanoTime();
        list.parallelStream()
            .filter(s -> s.length() > 4)
            .forEach(System.out::println);
        endTime = System.nanoTime();
        System.out.println("Parallel stream time: " + (endTime - startTime));
    }
}

常见的 Stream API 用法

按条件分组

使用 Collectors.partitioningBy 方法按条件将流分成两个组。

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class PartitioningByExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
        Map<Boolean, List<String>> partitioned = list.stream()
            .collect(Collectors.partitioningBy(s -> s.length() > 5));
        System.out.println("Length > 5: " + partitioned.get(true));
        System.out.println("Length <= 5: " + partitioned.get(false));
    }
}

按字段分组

使用 Collectors.groupingBy 方法按字段将流分组。

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class GroupingByExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("John", 20),
            new Person("Jane", 25),
            new Person("Jack", 20),
            new Person("Jill", 25)
        );
        Map<Integer, List<Person>> groupedByAge = people.stream()
            .collect(Collectors.groupingBy(Person::getAge));
        System.out.println(groupedByAge);
    }
    static class Person {
        private String name;
        private int age;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public int getAge() {
            return age;
        }
        @Override
        public String toString() {
            return name + " (" + age + ")";
        }
    }
}

聚合操作

使用 Collectors.summingInt、Collectors.averagingInt 等方法进行聚合操作。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class AggregationExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
            .collect(Collectors.summingInt(Integer::intValue));
        double average = numbers.stream()
            .collect(Collectors.averagingInt(Integer::intValue));
        System.out.println("Sum: " + sum);
        System.out.println("Average: " + average);
    }
}

总结

Java 8 引入的 Stream API 是一种强大的工具，使得处理集合类的数据更加简洁、高效和灵活。通过声明式的编程风格，开发者可以轻松地进行数据过滤、转换、聚合等操作，同时还能利用并行流充分发挥多核处理器的优势。本文详细介绍了 Stream API 的背景、优势、适用场景、组成部分、底层原理以及与其他同类技术的对比，并通过大量示例代码展示了 Stream API 的各种用法和高级应用。