Question

我正在研究Java Optional并测试一些超出标准用途的用例。

好的，我们来看看这个例子：

public void increment(Integer value) {
        if (currentValue != null && endValue != null && currentValue < (endValue - value)) {
            currentValue+=value;
        }
    }

currentValue和endValue为Integer。

上面的例子可以使用Optional？

在Java8中转换

我在想这样的事情：

public void increment(Integer value) {     
        currentValue.filter(a-> a < (endValue.get()-value)).map(???);
    }

其中currentValue和endValue为Optional<Integer>

我实际上坚持.map功能。

我很感激任何建议，谢谢

Answer 1

这个怎么样？

currentValue = currentValue.filter(it -> endValue.isPresent())
                           .filter(it -> it < endValue.get() - value)
                           .map(it -> Optional.of(it + value))
                           .orElse(currentValue);

或将value移到左侧比上面更简单。

currentValue = currentValue.map(it -> it + value)
                           .filter(it -> endValue.isPresent())
                           .filter(result -> result < endValue.get() )
                           .map(Optional::of)
                           .orElse(currentValue);

或

currentValue = currentValue.filter(it -> it < endValue.map(end -> end - value)
                                                      .orElse(Integer.MIN_VALUE))
                           .map(it -> Optional.of(it + value))
                           .orElse(currentValue);

或将value移到左侧比上面更简单。

currentValue=currentValue.map(it -> it + value)
                         .filter(result->result<endValue.orElse(Integer.MIN_VALUE))
                         .map(Optional::of)
                         .orElse(currentValue);

或改为使用Optional#flatMap：

currentValue = currentValue.flatMap(it ->
    endValue.filter(end -> it < end - value)
            .map(end -> Optional.of(it + value))
            .orElse(currentValue)
);

或将value移到左侧，然后可以使用简化的三元运算符：

currentValue = currentValue.map(it -> it + value).flatMap(result ->
    endValue.filter(end -> result < end)
            .isPresent() ? Optional.of(result) : currentValue
);

Answer 2

请注意，我认为没有选项，您的代码就可以了。如果您坚持要使用选项，请继续阅读。

您只想在value功能中添加map，对吧？然后在map电话中执行此操作：

x -> x + value

由于map返回Optional<Integer>，您应该将结果分配回currentValue：

currenValue = currentValue.filter(
    a -> a < endValue.get() - value).map(x -> x + value);

但是，如果endValue没有值，则会崩溃。

我在这里使用这个小技巧来完成这项工作：

currenValue = currentValue.filter(
    a -> a < endValue.orElse(Integer.MIN_VALUE + value) - value).map(x -> x + value).orElse(currentValue);

我们的想法是，如果endValue为空，则会将其替换为Integer.MIN_VALUE + value。 Integer.MIN_VALUE + value - value等于Integer.MIN_VALUE，其中任何数字都不能小于。 a < Integer.MIN_VALUE必须失败。

测试Java可选

2 个答案: