在流中使用 Java 8 Supplier 实现惰性求值

Question

我正在尝试在这样的流中使用供应商实现惰性评估

public static void main(String[] args) {

        Supplier<List<String>> expensiveListSupplier= getExpensiveList();
        getList().stream()
                .filter(s -> expensiveListSupplier.get().contains(s))
                .forEach(System.out::println);
    }

    private static Supplier<List<String>> getExpensiveList() {
        return () -> Stream
                .of("1", "2", "3")
                .peek(System.out::println)
                .collect(Collectors.toList());
    }

    private static List<String> getList() {
        return Stream.of("2", "3")
                .collect(Collectors.toList());
    }

但这会为列表中的每个元素调用 getExpensiveList() 方法。 我尽量不冗长，也不想写这样的东西，即添加不空的支票和东西。

public static void main(String[] args) {

        Supplier<List<String>> expensiveListSupplier = getExpensiveList();
        List<String> list = getList();
        if (!list.isEmpty()) {
            List<String> expensiveList = expensiveListSupplier.get();
            list.stream()
                    .filter(expensiveList::contains)
                    .forEach(System.out::println);
        }    
    }

    private static Supplier<List<String>> getExpensiveList() {
        return () -> Stream
                .of("1", "2", "3")
                .peek(System.out::println)
                .collect(Collectors.toList());
    }

    private static List<String> getList() {
        return Stream.of("2", "3")
                .collect(Collectors.toList());
    }

Answer 1

您的第二个变体可以简化为

List<String> list = getList();
if(!list.isEmpty()) {
    list.stream()
        .filter(getExpensiveList().get()::contains)
        .forEach(System.out::println);
}

它使Supplier 的使用毫无意义，因为即使是对getExpensiveList() 的调用也只有在列表非空时才会完成。但另一方面，这是你无论如何都可以获得的最大懒惰，即当另一个列表为空时不请求昂贵的列表。无论哪种情况，当列表不为空时，将已经为第一个元素请求昂贵的列表。

如果昂贵的列表可以变大，你应该使用

List<String> list = getList();
if(!list.isEmpty()) {
    list.stream()
        .filter(new HashSet<>(getExpensiveList().get())::contains)
        .forEach(System.out::println);
}

相反，以避免重复的线性搜索。或者重新设计getExpensiveList() 以首先返回Set。

Answer 2

我认为仅使用标准 Java 类是不可能的。但是您可以编写自己的惰性求值器并使用它，例如（未经测试）：

public class LazyValue<T> implements Supplier<T> {
    private T value;
    private final Supplier<T> initializer;
    public LazyValue(Supplier<T> initializer) {
        this.initializer = initializer;
    } 
    public T get() {
        if (value == null) {
            value = initializer.get();
        }
        return value;
    }
}

还有其他可能性，例如见this question。

但要小心！如果添加惰性求值，则数据结构是可变的，因此如果在多线程环境（或并行流）中使用它，请添加同步。

但是，我会使用您的详细版本。它是做什么的，一目了然，而且它只长了四行。 （在实际代码中，我希望这四行是无关紧要的。）