Java Stream peek vs. map关键要点研究表明，Java Stream 的 peek 和 map 都

关键要点

研究表明，Java Stream 的 peek 和 map 都是中间操作，但用途不同：peek 用于查看或调试，map 用于转换数据。
证据倾向于，peek 不改变流元素，适合副作用操作；map 返回新值，适合数据变换。
一个意想不到的细节是，peek 在某些情况下可能不执行，除非后续有终止操作。

直接回答

在 Java Stream 中，peek 和 map 都是中间操作，但功能和使用场景不同：

peek：用于查看流元素或执行副作用（如打印、修改外部状态），不改变流的内容，返回原始流。
map：用于转换流元素，将每个元素映射为新值，返回转换后的新流。

简单来说，peek 是“窥视”流的工具，适合调试或额外操作；map 是“变换”流的工具，适合生成新数据。

详细分析报告

引言

本报告对比 Java Stream 的 peek 和 map 操作，分析其定义、功能、使用场景和差异。Java Stream 是 Java 8 引入的函数式编程特性，用于处理集合数据。peek 和 map 作为中间操作，在流处理中扮演不同角色。基于2025年2月27日11:26 PM PST的当前时间，分析将参考 Java API 文档和实践经验，提供全面解读。

背景与定义

Java Stream：一种处理集合的抽象，包含中间操作（如 peek、map）和终止操作（如 collect、forEach）。
peek：接收一个 Consumer，对流中每个元素执行操作，返回原流。
map：接收一个 Function，将流中每个元素转换为新值，返回新流。

两者的共同点是都不立即执行（惰性求值），需终止操作触发。

功能与源码

peek：

定义：Stream<T> peek(Consumer<? super T> action)。
功能：对每个元素执行指定操作（如打印、记录日志），不改变元素本身。

源码（简化和伪代码）：

public Stream<T> peek(Consumer<? super T> action) {
    return new StatelessOp<T>(this) {
        @Override
        Sink<T> opWrapSink(Sink<T> sink) {
            return new Sink.ChainedReference<T>(sink) {
                @Override
                public void accept(T t) {
                    action.accept(t); // 执行副作用
                    downstream.accept(t); // 未修改元素
                }
            };
        }
    };
}

特点：副作用操作，不影响流内容。

map：

定义：<R> Stream<R> map(Function<? super T, ? extends R> mapper)。
功能：将每个元素映射为新值，生成新类型流。

源码（简化和伪代码）：

public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
    return new StatelessOp<R>(this) {
        @Override
        Sink<T> opWrapSink(Sink<R> sink) {
            return new Sink.ChainedReference<T>(sink) {
                @Override
                public void accept(T t) {
                    R result = mapper.apply(t); // 转换元素
                    downstream.accept(result); // 返回新值
                }
            };
        }
    };
}

特点：数据转换，返回新流。

使用场景与示例

peek：

场景：调试、记录日志、执行副作用。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3);
numbers.stream()
       .peek(n -> System.out.println("Processing: " + n))
       .collect(Collectors.toList());
// 输出:
// Processing: 1
// Processing: 2
// Processing: 3

map：

场景：数据转换、类型变换。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3);
List<String> strings = numbers.stream()
                              .map(n -> "Number " + n)
                              .collect(Collectors.toList());
// 结果: ["Number 1", "Number 2", "Number 3"]

对比分析

以下表格总结两者的差异：

特性	`peek`	`map`
用途	查看、调试、副作用	数据转换、映射
输入	Consumer（无返回值）	Function<T, R>（返回新值）
输出	原流（Stream）	新流（Stream）
改变元素	不改变，仅执行操作	改变，返回新值
典型场景	打印日志、调试	格式化数据、类型转换
执行条件	需终止操作，可能不执行	需终止操作，转换后影响结果

意外细节

peek 的惰性：若无终止操作（如 collect），peek 可能不执行。例如：

Stream.of(1, 2, 3).peek(System.out::println); // 无输出

需添加 forEach 或 collect：

Stream.of(1, 2, 3).peek(System.out::println).forEach(n -> {});

map 的类型灵活性：可将 Stream<Integer> 转换为 Stream<String>，而 peek 不能改变类型。

适用场景与建议

选择 peek：需要检查流状态、调试或执行不影响结果的操作。
选择 map：需要转换数据或生成新流。

结合使用：

List<String> result = Stream.of(1, 2, 3)
                            .peek(n -> System.out.println("Before: " + n))
                            .map(n -> "Num " + n)
                            .peek(s -> System.out.println("After: " + s))
                            .collect(Collectors.toList());

结论

peek 和 map 是 Java Stream 的重要中间操作，peek 适合查看和副作用，map 适合数据转换。两者功能互补，选择取决于是否需要改变流内容。注意 peek 的惰性特性，确保有终止操作触发。

Java Stream peek vs. map