Stream<T> peek(Consumer<? super T> action);

List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> doubled = nums.stream()
    .peek(n -> System.out.println("原始值: " + n))  // 觀察元素
    .map(n -> n * 2)
    .peek(n -> System.out.println("翻倍后: " + n))  // 觀察轉(zhuǎn)換后的值
    .collect(Collectors.toList());

// 危險示例：并行流中修改共享列表
List<Integer> result = new ArrayList<>();
Arrays.asList(1, 2, 3, 4).parallelStream()
    .peek(n -> result.add(n * 2))  // 多線程同時添加元素
    .collect(Collectors.toList());
// 可能拋出ConcurrentModificationException，或元素重復(fù)/丟失

// 錯誤示例：peek修改元素導(dǎo)致排序混亂
List<User> users = Arrays.asList(
    new User("Alice", 25),
    new User("Bob", 20)
);
users.stream()
    .peek(u -> u.setAge(u.getAge() + 5))  // 修改年齡
    .sorted(Comparator.comparingInt(User::getAge))
    .forEach(u -> System.out.println(u.getName() + " " + u.getAge()));
// 排序依據(jù)的是修改后的年齡，但peek的執(zhí)行順序可能與排序邏輯沖突

// 低效示例：每行日志都執(zhí)行peek打印
List<String> logs = Files.readAllLines(path);
long errorCount = logs.stream()
    .peek(System.out::println)  // 每行都打印，IO開銷巨大
    .filter(l -> l.contains("ERROR"))
    .count();

// 調(diào)試流操作鏈
List<String> result = dataStream
    .peek(s -> System.out.println("過濾前: " + s))
    .filter(this::validate)
    .peek(s -> System.out.println("過濾后: " + s))
    .map(this::transform)
    .collect(Collectors.toList());

// 安全示例：單線程流中復(fù)制對象
List<Product> products = originalList.stream()
    .peek(p -> p = new Product(p))  // 淺拷貝
    .collect(Collectors.toList());

// 僅在收集時執(zhí)行副作用
AtomicInteger counter = new AtomicInteger();
List<String> result = dataStream
    .peek(s -> {
        if (counter.incrementAndGet() % 1000 == 0) {
            log.info("處理了1000個元素");  // 惰性日志輸出
        }
    })
    .collect(Collectors.toList());

// 反例：peek修改對象屬性（副作用）
users.stream()
    .peek(u -> u.setStatus("ACTIVE"));  // 直接修改原對象
// 優(yōu)化：用map創(chuàng)建新對象（無副作用）
List<User> activeUsers = users.stream()
    .map(u -> new User(u.getId(), u.getName(), "ACTIVE"))
    .collect(Collectors.toList());

// 危險：peek修改共享計數(shù)器
AtomicInteger count = new AtomicInteger();
dataStream.parallel()
    .peek(s -> count.incrementAndGet());  // 多線程競爭
// 安全：用Collector統(tǒng)計
long safeCount = dataStream.parallel()
    .collect(Collectors.counting());

// 低效：流中執(zhí)行打印
dataStream.forEach(s -> {
    process(s);
    System.out.println(s);  // 副作用
});
// 高效：先處理再統(tǒng)一輸出
List<String> processed = dataStream.map(this::process).collect(Collectors.toList());
processed.forEach(System.out::println);