Question

使用Java8，可以这样做：

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

而不是：

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

问题：我们可以选择布尔到java8吗？换句话说，我们可以写出类似的东西：

if(boolVar)
    return trueResult;
return falseResult;

而不是：

{{1}}

编辑＃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

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

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。

我们可以像对Optionals一样采用布尔值到Java8（ifPresent和orElse）

4 个答案: