Java为什么没有条件和和条件或运算符的复合赋值版本？（&& =，|| =）

因此，对于在布尔二元运算符，Java有&，|，^，&&和||。

让我们在这里简要总结一下他们的工作：

• JLS 15.22.2布尔逻辑运算符＆，^和|
• JLS 15.23条件与运算符&&
• JLS 15.24条件或运算符||

对于&，结果值是true两个操作数都为true; 否则，结果为false。

对于|，结果值是false两个操作数都为false; 否则，结果为true。

对于^，结果值是true操作数值是否不同；否则，结果为false。

该&&操作是一样&，但是评估其右边的操作数只有在其左侧的值操作数true。

该||操作是一样|的，但评估其右边的操作数只有在其左侧的值操作数false。

现在，所有5间，那些3有复合赋值版本，分别为|=，&=和^=。所以我的问题是显而易见的：为什么不是Java提供&&=和||=呢？我发现我需要那些比我更需要&=和|=。

而且我不认为“因为它太长”是一个很好的答案，因为Java具有>>>=。一定有一个更好的理由可以忽略这一点。

从15.26分配运算符开始：

有12个赋值运算符；[...]= *= /= %= += -= <<= >>= >>>= &= ^= |=

有人评论说，如果&&=和||=被实施，那么它将是唯一不首先评估右侧的运营商。我认为，复合赋值运算符首先评估右侧的这一观点是错误的。

从15.26.2复合赋值运算符开始：

形式的复合赋值表达式E1 op= E2等效于E1 = (T)((E1) op (E2))，其中T是的类型E1，不同之处在于该表达式E1仅被评估一次。

为了证明这一点，以下代码段抛出NullPointerException，而不是ArrayIndexOutOfBoundsException。

    int[] a = null;
    int[] b = {};
    a[0] += b[-1];

原因

运算符&&=和||=在Java上不可用，因为对于大多数开发人员而言，这些运算符是：

• 容易出错
• 无用

范例 &&=

如果Java允许&&=运算符，则该代码：

bool isOk = true; //becomes false when at least a function returns false
isOK &&= f1();
isOK &&= f2(); //we may expect f2() is called whatever the f1() returned value

等同于：

bool isOk = true;
if (isOK) isOk = f1();
if (isOK) isOk = f2(); //f2() is called only when f1() returns true

第一个代码容易出错，因为许多开发人员会认为f2()无论f1（）返回值是什么，它总是被称为。就像只有在返回时才在bool isOk = f1() && f2();哪里f2()调用。f1()true

如果开发人员希望f2()将被称为仅当f1()返回true，因此，第二代码是以上更不易出错。

否则&=就足够了，因为开发人员希望f2()始终被称为：

相同的例子，但是 &=

bool isOk = true;
isOK &= f1();
isOK &= f2(); //f2() always called whatever the f1() returned value

此外，JVM应该按照以下代码运行以上代码：

bool isOk = true;
if (!f1())  isOk = false;
if (!f2())  isOk = false;  //f2() always called

相比 &&和&结果

是运算符的结果 &&，并&同当布尔值应用？

让我们使用以下Java代码进行检查：

public class qalcdo {

    public static void main (String[] args) {
        test (true,  true);
        test (true,  false);
        test (false, false);
        test (false, true);
    }

    private static void test (boolean a, boolean b) {
        System.out.println (counter++ +  ") a=" + a + " and b=" + b);
        System.out.println ("a && b = " + (a && b));
        System.out.println ("a & b = "  + (a & b));
        System.out.println ("======================");
    }

    private static int counter = 1;
}

输出：

1) a=true and b=true
a && b = true
a & b = true
======================
2) a=true and b=false
a && b = false
a & b = false
======================
3) a=false and b=false
a && b = false
a & b = false
======================
4) a=false and b=true
a && b = false
a & b = false
======================

因此是我们可以更换&&的&布尔值;-)

所以更好地使用 &=代替&&=。

相同的 ||=

与以下原因相同&&=：
运算符|=比||=。

如果开发者想f2()不被调用时f1()的回报true，那么我建议以下选择：

// here a comment is required to explain that 
// f2() is not called when f1() returns false, and so on...
bool isOk = f1() || f2() || f3() || f4();

要么：

// here the following comments are not required 
// (the code is enough understandable)
bool isOk = false;
if (!isOK) isOk = f1();
if (!isOK) isOk = f2(); //f2() is not called when f1() returns false
if (!isOK) isOk = f3(); //f3() is not called when f1() or f2() return false
if (!isOK) isOk = f4(); //f4() is not called when ...

可能是因为

x = false;
x &&= someComplexExpression();

看起来应该分配x和评估someComplexExpression()，但是评估取决于评估的价值。x从语法上看，求并不明显。

同样由于Java的语法基于C，并且没有人迫切需要添加这些运算符。无论如何，使用if语句可能会更好。

在Java中是这样，因为在C中是这样。

现在，为什么在C中如此的问题是因为当＆和&&成为不同的运算符时（有时在C从B下降之前），＆=多种运算符被忽略了。

但是我的答案的第二部分没有任何来源可以支持它。

很大程度上是因为Java语法基于C（或至少是C系列），并且在C中，所有这些赋值运算符都在单个寄存器上被编译为算术或按位汇编指令。赋值运算符版本可避免临时使用，并且可能会在早期的非优化编译器上产生更有效的代码。逻辑运算符（用C表示）的等效项（&&=和||=）与单个汇编指令之间没有明显的对应关系。它们通常扩展为测试和分支指令序列。

有趣的是，像ruby这样的语言确实具有|| =和&& =。

编辑：Java和C之间的术语不同

Java的最初目标之一是成为“简单，面向对象和熟悉”。在这种情况下，＆=很熟悉（C，C ++对此很熟悉，在这种情况下，这意味着对熟悉这两个知识的人来说很熟悉）。

&& =不会很熟悉，也不会很简单，因为语言设计人员不会考虑要添加到该语言中的每个运算符，因此，多余的运算符会更简单。

对于布尔变量，&&和|| 将在＆和|时使用短路评估 不会，因此您会期望&& =和|| =也使用短路评估。有一个很好的用例。特别是如果您要遍历一个循环，则希望快速，高效且简洁。

而不是写

foreach(item in coll)
{
   bVal = bVal || fn(item); // not so elegant
}

我想写

foreach(item in coll)
{
  bVal ||= fn(item);    // elegant
}

并且知道一旦bVal为true，就不会在其余的迭代中调用fn（）。

“ &”和“ &&”与“ &&”是一种捷径操作，如果第一个操作数为假，则&不会执行，而“ ”仍会执行此操作（同时使用number和boolean）。

我确实同意存在的意义更大，但是如果不存在的话也并不坏。我猜它不存在，因为C没有它。

真的想不出原因。

在Ruby中允许。

如果我猜到了，我会说它不经常使用，因此没有实现。另一个解释可能是解析器仅查看=之前的字符。

我再也想不出更好的理由，“看起来丑陋！”

和

验证两个操作数，这是按位运算符。Java定义了几个按位运算符，它们可以应用于整数类型long，int，short，char和byte。

&&

如果第一个操作数的结果为假，则停止计算，因为结果为假，这是一个逻辑运算符。它可以应用于布尔值。

&&运算符类似于＆运算符，但是可以使您的代码更高效。因为＆运算符比较的两个表达式都必须为true，才能使整个表达式为true，因此如果第一个表达式返回false，则没有理由评估第二个表达式。＆运算符始终对两个表达式求值。&&运算符仅在第一个表达式为true时才对第二个表达式求值。

拥有&& =赋值运算符并不会真正为该语言添加新功能。按位运算符的算术表达性更高，可以执行整数按位算术，其中包括布尔算术。逻辑运算符只能执行布尔运算。

Brian Goetz（Oracle Java语言架构师）写道：

https://stackoverflow.com/q/2324549/ [此问题]表明拥有这些运算符是有兴趣的，并且尚无明确的论据说明为什么它们不存在。因此，问题是：JDK团队过去是否讨论过添加这些运算符，如果是，则反对添加它们的原因是什么？

我不知道有关此特定问题的任何具体讨论，但是如果有人提出它，答案可能是：这不是一个不合理的请求，但它并不重要。

需要根据其成本和收益以及相对于其他候选功能的成本效益比来判断“担负重”。

我认为您是在隐式假设（用短语“有利息”表示）成本接近零且收益大于零，因此这似乎是一个明显的胜利。但这掩盖了对成本的错误理解。这样的功能会影响语言规范，实现，JCK以及每个IDE和Java教科书。没有琐碎的语言功能。而且，收益虽然非零，却很小。

其次，我们可以无限地完成许多功能，但是每隔几年我们只能做少数几个功能（并且用户吸收新功能的能力有限。）因此我们在选择时必须非常小心，因为每个功能（甚至是微不足道的功能）都会消耗一部分预算，并且总是将其从其他预算中夺走。
这不是“为什么没有此功能”，而是“我们将不做（或延迟）其他什么功能，以便我们可以做到这一点，这是一笔好买卖吗？” 我真的无法想象这与我们正在努力的任何其他事物之间都是一笔不错的交易。

因此，它清除了“一个绝妙的主意”的标准（这已经相当不错了，很多功能请求甚至都没有清除它），但是似乎不太可能清除“更好地利用我们的发展预算”的标准。比什么都重要。”

a＆b和a && b是不同的东西。

a && b是返回布尔值的布尔表达式，而a＆b是返回整数（如果a和b是整数）的按位表达式。

你认为他们是一样的吗？