Java中从固定表达式集合生成惰性流的实践指南

import java.util.function.Supplier;
import java.util.stream.Stream;

// 假设我们有一个MyClass类型
class MyClass {
    private String name;
    public MyClass(String name) { this.name = name; }
    public String getName() { return name; }
    @Override
    public String toString() { return "MyClass{" + "name='" + name + '\'' + '}'; }
}

public class LazyStreamConstruction {

    // 模拟一个可能耗时的表达式
    private static MyClass createMyClass(String id) {
        System.out.println("正在创建 MyClass 实例: " + id);
        // 模拟一些耗时操作
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return new MyClass("实例 " + id);
    }

    public static void main(String[] args) {
        System.out.println("--- 开始构建 Stream<Supplier<MyClass>> ---");

        Stream<Supplier<MyClass>> lazyStreamOfSuppliers = Stream.of(
            () -> createMyClass("A"), // 表达式被封装，尚未执行
            () -> createMyClass("B"), // 表达式被封装，尚未执行
            () -> createMyClass("C")  // 表达式被封装，尚未执行
        );

        System.out.println("Stream<Supplier<MyClass>> 已构建，内部表达式尚未触发执行。");
        // 此时，createMyClass("A"), createMyClass("B"), createMyClass("C") 均未被调用。
    }
}

import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;

// MyClass 定义同上
class MyClass {
    private String name;
    public MyClass(String name) { this.name = name; }
    public String getName() { return name; }
    @Override
    public String toString() { return "MyClass{" + "name='" + name + '\'' + '}'; }
}

public class LazyStreamEvaluation {

    private static MyClass createMyClass(String id) {
        System.out.println("正在创建 MyClass 实例: " + id);
        try {
            Thread.sleep(100); // 模拟耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return new MyClass("实例 " + id);
    }

    public static void main(String[] args) {
        Stream<Supplier<MyClass>> lazyStreamOfSuppliers = Stream.of(
            () -> createMyClass("A"),
            () -> createMyClass("B"),
            () -> createMyClass("C"),
            () -> createMyClass("D")
        );

        System.out.println("\n--- 开始通过 map(Supplier::get) 触发评估 ---");
        // 假设我们只想找到第一个名字包含 "C" 的实例
        Optional<MyClass> firstMatch = lazyStreamOfSuppliers
            .map(Supplier::get) // 在这里，每个Supplier的get()方法才会被调用
            .filter(myObj -> myObj.getName().contains("C"))
            .findFirst(); // 终端操作，触发流管道执行

        if (firstMatch.isPresent()) {
            System.out.println("找到第一个匹配项: " + firstMatch.get());
        } else {
            System.out.println("未找到匹配项。");
        }
        System.out.println("--- 评估结束 ---");
        // 观察输出，你会发现只有 "A", "B", "C" 的 createMyClass 被执行，"D" 未被执行。
    }
}