我们是否可以像 Optionals (ifCurrent 和 orElse) 一样将布尔值采用到 Java8 中

Question

使用Java8，可以做到这一点：

Optional.ofNullable(realResult).orElse(mockResult);

而不是：

if(realResult == null)
return mockResult;
return realResult;

问题：我们可以将

---

布尔值加入java8吗？或者换句话说，我们可以写这样的东西吗：

Boolean.valueOf(boolVar).ifTrue(trueResult).orElse(falseResult);

而不是：

if(boolVar)
return trueResult;
return falseResult;

编辑#1感谢您建议三元操作，仍然想知道我们是否可以？

Answer 1

使用语言中已经包含的三元运算符怎么样？

boolVar ? trueResult : falseResult

编辑：如果你真的想要这样一个类，这就是它的样子：

public class Conditional<T> {
private final boolean condition;
private T valueWhenTrue;
public static Conditional valueOf(boolean condition) {
return new Conditional(condition);
}
private Conditional(boolean condition) {
this.condition = condition;
}
public Conditional ifTrue(T valueWhenTrue) {
this.valueWhenTrue = valueWhenTrue;
return this;
}
public T orElse(T valueWhenFalse) {
return condition ? valueWhenTrue : valueWhenFalse;
}
}

用法：

Conditional.valueOf(boolVar).ifTrue(trueResult).orElse(falseResult)

Answer 2

java.lang.Boolean

没有ifTrue()方法。

你可以编写自己的Boolean实现，让它做任何你喜欢的事情，但我不明白为什么你不使用现有的模式来处理布尔值，这些模式工作得很好。

有很多奇怪而奇妙的可能性：

return Stream.of(Boolean.valueOf(b))
.filter(Function.identity())
.map( b -> trueResult)
.findAny()
.orElse( falseResult);
----
return Optional.of(b)
.filter(function.identity())
.map( b -> trueResult)
.orElse(falseResult);

。但是，当使用原语的三元运算符在内存和操作方面都更清晰、更短、更高效时，您为什么要这样做：

return b ? trueResult : falseResult;

Answer 3

我不会在我的代码中这样做，但因为你问，你可以使用 stream 和这种操作

2个例子：

private static String boolString(boolean boolVar) {
return Stream.of(boolVar).filter(b -> b).map(x -> "foo").findFirst().orElse("bar");
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
private static int boolInt(boolean boolVar) {
return Stream.of(boolVar).filter(b -> b).map(x -> 1).findFirst().orElse(0);
}

---

像这样使用：

public static void main(String args[]) {
System.out.println(boolInt(true));       //1
System.out.println(boolInt(false));      //0
System.out.println(boolString(true));    //foo
System.out.println(boolString(false));   //bar
}

---

但ternary-operator或经典if更易于使用

Answer 4

你可以创建这样的东西：

public class Wrap<T> {
private final boolean value;
public Wrap(final boolean value) {
this.value = value;
}
public Optional<T> ifTrue(final T ob) {
if(value) {
return Optional.ofNullable(ob);
}
return Optional.empty();
}
}

和：

public final class BooleanWraper {
private BooleanWraper() {
}
public static <T> Wrap<T> valueOf(final boolean value) {
return new Wrap<>(value);
}
}

然后使用它：

final String value = BooleanWraper.<String>valueOf(true)
.ifTrue("true")
.orElse("false");

它最终使用的是Optional。