Java 无条件三元

我读过类似的问题，了解到不可能使用三元运算来代替没有

else

语句的

if

语句。因为，

if-without-else

语句是二进制而不是三元的。我的问题是更多的最佳实践

在我的代码中，有很多这样的代码片段

  if( calculation < 1 ){
      calculation= 0;
    }

if（计算<1）{
计算=0；
}

我想用十位数来缩短这些。使用以下语句更改这些语句是否是一种良好的做法

calculation = calculation < 1 ? 0 : calculation;

calculation=calculation<1？0：计算；

您可以创建一个（或多个）类来创建一个非常流畅的API。这样，您的线路将是：

calculationTo = replace(calculationTo).with(0).when(calculationTo < 1)

calculationTo=replace（calculationTo）.with（0）.when（calculationTo<1）

在我看来，它并不比标准的if语句好多少，但它也取决于你的条件

实施示例：

public class Replacer<T> {

    private final T value;
    private T replacementValue;

    private Replacer(T value) {
        this.value = value;
    }

    public static <V> Replacer<V> replace(V value) {
        return new Replacer<V>(value);
    }

    public Replacer<T> with (T replacementValue) {
        this.replacementValue = replacementValue;
        return this;
    }

    public T when(boolean condition) {
        if (condition) {
            return replacementValue;
        } else {
            return value;
        }
    }

}

公共类替换程序{
私人最终T值；
私人T替代值；
专用替换程序（T值）{
这个值=值；
}
公共静态替换器替换（V值）{
返回新的替换项（值）；
}
具有（T replacementValue）的公共替换程序{
this.replacementValue=replacementValue；
归还这个；
}
公共T时（布尔条件）{
如果（条件）{
返回replacementValue；
}否则{
返回值；
}
}
}

---

导入静态somepackage.Replacer.replace；
公共班机{
公共静态void main（字符串[]args）{
int计算到=3；
calculationTo=用（0）替换（calculationTo.）。当（calculationTo<1）；
}
}

您可以扩展它或使条件成为一个函数，以便与lambda等一起使用。我还将使方法

与

一起返回不同类的对象（例如，

ReplacerWithValue

），以便在一个链中使用两次调用

，将导致编译错误。
您可以创建一个或多个类这将创建一个非常流畅的API。这样，您的线路将是：

calculationTo = replace(calculationTo).with(0).when(calculationTo < 1)

calculationTo=replace（calculationTo）.with（0）.when（calculationTo<1）

在我看来，它并不比标准的if语句好多少，但它也取决于你的条件

实施示例：

public class Replacer<T> {

    private final T value;
    private T replacementValue;

    private Replacer(T value) {
        this.value = value;
    }

    public static <V> Replacer<V> replace(V value) {
        return new Replacer<V>(value);
    }

    public Replacer<T> with (T replacementValue) {
        this.replacementValue = replacementValue;
        return this;
    }

    public T when(boolean condition) {
        if (condition) {
            return replacementValue;
        } else {
            return value;
        }
    }

}

公共类替换程序{
私人最终T值；
私人T替代值；
专用替换程序（T值）{
这个值=值；
}
公共静态替换器替换（V值）{
返回新的替换项（值）；
}
具有（T replacementValue）的公共替换程序{
this.replacementValue=replacementValue；
归还这个；
}
公共T时（布尔条件）{
如果（条件）{
返回replacementValue；
}否则{
返回值；
}
}
}


导入静态somepackage.Replacer.replace；
公共班机{
公共静态void main（字符串[]args）{
int计算到=3；
calculationTo=用（0）替换（calculationTo.）。当（calculationTo<1）；
}
}

您可以扩展它或使条件成为一个函数，以便它可以与lambda一起使用，等等。我还将使方法
具有不同类的返回对象（例如
ReplacerWithValue
），以便在一个链中使用
两次调用
将导致编译错误。
因为您要求的是最佳实践，我会指出一些你可以做得更好的地方，然后我会告诉你为什么我喜欢三元运算符

让我重新表述一下您的代码片段：

if (calculatedValueAfterStep1 < 1) {
    calculatedValueAfterStep2 = 0;
} else {
    calculatedValueAfterStep2 = calculatedValueAfterStep1;
}

if（步骤1<1后的计算值）{
步骤2后的计算值=0；
}否则{
calculatedValueAfterStep2=calculatedValueAfterStep1；
}

当您阅读代码时，有人问您“计算”代表什么？”那么您在回答这个问题时必须询问行号。“计算”的含义随着程序代码的变化而变化。如果不能解释变量的含义，就不能给它起个好名字。这就是为什么我更喜欢我的版本。变量“calculatedValueAfterStep1”和“calculatedValueAfterStep2”的含义有一个明确的定义。是的，名字不好。相应地将它们更改为您的域

现在，当您查看代码时，您会注意到“calculatedValueAfterStep2”没有声明。因此，让我们更改代码：

int calculatedValueAfterStep2 = -1;
if (calculatedValueAfterStep1 < 1) {
    calculatedValueAfterStep2 = 0;
} else {
    calculatedValueAfterStep2 = calculatedValueAfterStep1;
}

int calculatedValueAfterStep2=-1；
if（步骤1后的计算值<1）{
步骤2后的计算值=0；
}否则{
calculatedValueAfterStep2=calculatedValueAfterStep1；
}

现在它变丑了。问前面问题的人现在会问“为什么'calculatedValueAfterStep2'用'-1'初始化？”。这是三元运算符：

int calculatedValueAfterStep2 = (calculatedValueAfterStep1 < 1) ? 0 : calculatedValueAfterStep2;

int calculatedValueAfterStep2=（calculatedValueAfterStep1<1）？0：步骤2后的计算值；

漂亮
 既然您要求的是最佳实践，我将指出您可以做得更好的地方，然后我将告诉您为什么我喜欢三元运算符

让我重新表述一下您的代码片段：

if (calculatedValueAfterStep1 < 1) {
    calculatedValueAfterStep2 = 0;
} else {
    calculatedValueAfterStep2 = calculatedValueAfterStep1;
}

if（步骤1<1后的计算值）{
步骤2后的计算值=0；
}否则{
calculatedValueAfterStep2=calculatedValueAfterStep1；
}

当您阅读代码时，有人问您“计算”代表什么？”那么您在回答这个问题时必须询问行号。“计算”的含义随着程序代码的变化而变化。如果不能解释变量的含义，就不能给它起个好名字。这就是为什么我更喜欢我的版本。变量“calculatedValueAfterStep1”和“calculatedValueAfterStep2”的含义有一个明确的定义。是的，名字不好。相应地将它们更改为您的域

现在，当您查看代码时，您会注意到“calculatedValue”