2

map()filter()ofOptional是懒惰的吗Stream

我如何确认他们的类型?

4

2 回答 2

9

Streama和a 之间有根本的区别Optional

AStream封装了整个处理管道,在做任何事情之前收集所有操作。这允许实现选择不同的处理策略,具体取决于实际请求的结果。这也允许在链中插入类似unordered()或的修饰符parallel(),因为在这一点上,到目前为止还没有做任何事情,所以我们可以改变后续实际处理的行为。

一个极端的例子是,它在 Java 9 中Stream.of(1, 2, 3).map(function).count()根本不会处理,因为没有 的不变结果可以确定。function3

相反, anOptional只是一个值的包装器(如果不是空的)。每个操作都将立即执行,以返回Optional封装新值的新值或空值Optional。在 Java 8 中,所有返回 、 即 或 的方法在Optional应用于空可选项时只会返回空可选项,因此在链接它们时,空可选项成为一种死胡同。mapflatMapfilter

但是 Java 9 将引入Optional<T> or​(Supplier<? extends Optional<? extends T>>),当应用于空的可选项时,它可能会从供应商处返回一个非空的可选项。

由于 anOptional表示(可能不存在)值,而不是处理管道,因此无论查询返回新值还是最终值,您都可以查询Optional多次。Optional

很容易验证。以下代码

Optional<String> first=Optional.of("abc");
Optional<String> second=first.map(s -> {
    System.out.println("Running map");
    return s + "def";
});
System.out.println("starting queries");
System.out.println("first: "+(first.isPresent()? "has value": "is empty"));
System.out.println("second: "+(second.isPresent()? "has value": "is empty"));
second.map("second's value: "::concat).ifPresent(System.out::println);

将打印

Running map
starting queries
first: has value
second: has value
second's value: abcdef

证明映射函数在任何其他查询之前立即被评估,并且我们仍然可以first在我们创建第二个 viamap并多次查询可选项之后查询可选项。

事实上,强烈建议isPresent()在调用之前先检查 via get()

没有等效的流代码,因为以Stream这种方式重用实例是无效的。但是我们可以证明在终端操作开始之前没有执行中间操作:

Stream<String> stream=Stream.of("abc").map(s -> {
    System.out.println("Running map");
    return s + "def";
});
System.out.println("starting query");
Optional<String> result = stream.findAny();
System.out.println("result "+(result.isPresent()? "has value": "is empty"));
result.map("result value: "::concat).ifPresent(System.out::println);

将打印

starting query
Running map
result has value
result value: abcdef

表明在终端操作findAny()开始之前未评估映射函数。由于我们不能多次查询一个流,findAny()甚至可以Optional用作返回值,这允许我们对最终结果执行此操作。


同名操作之间还有其他语义差异,例如,如果映射函数计算结果为,Optional.map将返回空值。对于流,传递给的函数是返回还是非值没有区别(这就是为什么我们可以在不知道是否返回的情况下计算元素)。Optionalnullmapnullnull

于 2017-05-29T16:10:37.637 回答
5
 String r = Optional.of("abc")
            .map(s -> {
                System.out.println("Running map");
                return s + "def";
            })
            .filter(s -> {
                System.out.println("First Filter");
                return s.equals("abcdef");
            })
            .map(s -> {
                System.out.println("mapping");
                return s + "jkl";
            })
            .orElse("done");

    System.out.println(r);

运行它会产生:

运行图,First Filter,映射 abcdefjkl

另一方面运行这个:

String r = Optional.of("mnt") //changed
            .map(s -> {
                System.out.println("Running map");
                return s + "def";
            })
            .filter(s -> {
                System.out.println("First Filter");
                return s.equals("abcdef");
            })
            .map(s -> {
                System.out.println("mapping");
                return s + "jkl";
            })
            .orElse("done");

运行图,第一个过滤器,完成

我一直认为,既然map只是在前一个的基础上执行filter,那就会考虑这个lazy。事实证明这不是真的

 Optional.of("s").map(String::toUpperCase)
 Stream.of("test").map(String::toUpperCase)

mapfrom将Optional被执行;而从Stream不会。

编辑

去这里投票另一个答案。这是因为另一个而被编辑的。

于 2017-05-26T13:29:49.647 回答