Question

请考虑以下课程：

ClassA {
}

ClassB {
    private ClassA classA;

    // getters and setters
}

由于peek上没有Optional方法可用，因此认为这是在滥用Optional#map方法：

return myService.findA()
        .flatMap(a -> myService.findB(a) // also returns optional
                    .map(b -> {
                            b.setClassA(a);
                            return b;
                        }))
        .map(d -> MyType.of(d)) // MyType being other class
        .orElse(MyType.empty());

这也可以这样写：

Optional<ClassA> optionalA = myService.findA();

if (optionalA.isPresent()) {
    Optional<ClassB> optionalB = myService.findB(optionalA.get());

    if (optionalB.isPresent()) {
        ClassB classB = optionalB.get();
        classB.setClassA(optionalA.get());
        return MyType.of(classB);
}
return MyType.empty();

两个实现都执行相同的逻辑，是否应该优先选择另一个？

Answer 1

在我看来，x <- 2 test() [1] 4并没有暗示rm(x); test2 <- function() { x <- 2; test() }; test2()，这似乎很奇怪，因为它既有范围，但无论如何，这里没有必要滥用myService.findB(a)：< / p>

b.setClassA(a)

Answer 2

因此，当您应用功能设计原则时，就永远不会更新状态。这意味着没有任何允许这样做的数据结构（如带有该setter的ClassB的情况）。您宁愿使用更新后的值返回该类的新实例。而且，如果这样做，则无需map或flatMap来“滥用”，但您可以使用闭包代替：

return myService.findA()
    .flatMap(a -> myService.findB(a).map(b -> b.copyWith(a)))
    .map(MyType::of)
    .orElse(MyType.empty());

Answer 3

我可能更喜欢第一个实现，因为Optional提供了转换的主要功能，我认为最好将其很好地利用。

考虑到不存在Optional＃peek方法而滥用Optional＃map

3 个答案: