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

Question

因此，对于布尔值的二元运算符，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];

Answer 1

Java 最初的目标之一是“简单、对象”既熟悉又熟悉。”应用于本例时，&= 很熟悉（C、C++ 都有它，在这种情况下熟悉意味着了解这两个的人很熟悉）。

&&= 不会让人熟悉，也不会简单，因为语言设计者并不想考虑他们可以添加到语言中的每个运算符，因此额外的运算符越少就越简单。

Answer 2

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

<块引用>

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

我不知道关于这个特定问题的任何具体讨论，但是
如果有人提出这个建议，答案很可能是：这不是一个
虽然要求不合理，但没有分量。

“承载力”需要根据成本和收益来判断，
通过其相对于其他候选特征的成本效益比。

我认为你隐含地假设（通过“有兴趣”这个短语）
成本接近于零，而收益大于零，所以
似乎是明显的胜利。但这掩盖了一种不正确的理解
成本;像这样的功能会影响语言规范、实现，
JCK，以及每一本 IDE 和 Java 教科书。没有琐碎的语言
特征。收益虽然非零，但相当小。

其次，我们可以实现无限多的功能，但是我们
每隔几年只有能力做几次（并且用户有
吸收新功能的能力有限。）所以我们必须非常小心
至于我们选择哪个，因为每个功能（即使是看似微不足道的功能）
消耗了部分预算，并且总是从其他预算中夺走。
不是“为什么不做这个功能”，而是“还有哪些功能我们不会做”
（或延迟），这样我们就可以做这件事，这是一笔好的交易吗？”
真的无法想象这与我们的其他任何交易相比是一笔很好的交易
正在努力。

所以，它清除了“不是一个糟糕的主意”的标准（这已经很漂亮了）
很好，很多功能请求甚至没有明确这一点），但似乎
不太可能清除“更好地利用我们的进化预算”的障碍
比其他任何事情都重要。”

Answer 3

对于布尔变量， &&和 ||将使用短路评估，而 &和|不这样做，所以您会期望 &&= 和 ||= 也使用短路评估。这有一个很好的用例。特别是当您在循环上进行迭代时，您希望快速、高效且简洁。

而是

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

我不想写，

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

想写并知道一旦 bVal 为 true，fn() 将不会在剩余的迭代中被调用。

Answer 4

'&' 和 '&&' 与 '&&' 不同，它是一个快捷操作如果第一个操作数为 false 则不执行，而 '&' 无论如何都会执行（适用于数字和布尔值）。

我确实同意它的存在更有意义，但如果它不存在也没有那么糟糕。我猜它不在那里，因为 C 没有它。

实在想不出为什么。

Answer 5

有趣的是我遇到了这个问题。

运算符 ||= 和 &&= 不存在，因为它们的语义很容易被误解；
如果您认为需要它们，请改用 if 语句。

伊利（上面的帖子）的要点是正确的：

||

如果第一个操作数的计算结果为真，则停止计算，因为结果将为真，它是一个逻辑运算符。

所以想象一下如果 b == true 会发生什么；

b ||= somereturningaboolean(); //!!??

如果 b == true，则不会调用 somereturningaboolean()。

这种行为在长形式中更为明显：

b = b ||某物返回布尔值（）；

这就是为什么 ||= 和 &&= 操作不存在。解释应如下：
运算符 ||= 和 &&= 不存在，因为它们的语义很容易被误解；
如果您认为需要它们，请改用 if 语句。

Answer 6

Ruby 中允许这样做。

如果我猜的话，我会说它不经常使用，所以没有实现。另一种解释可能是解析器只查看 = 之前的字符

Answer 7

我想不出比“它看起来丑得令人难以置信！”更好的理由了。

Answer 8

&

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

&&

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

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

使用 &&= 赋值运算符并不会真正为该语言添加新功能。按位运算符的算术更具表现力，可以进行整数按位算术，其中包括布尔算术。逻辑运算符只能进行布尔算术。

Answer 9

原因

运算符 &&= 和 ||= 在 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

第一个代码是 错误-容易，因为许多开发人员会认为无论 f1() 返回值如何，f2() 总是被调用。就像 bool isOk = f1() && f2(); 其中，仅当 f1() 返回 true 时才会调用 f2()。

如果开发人员希望仅当 f1() 返回 true 时才调用 f2()，因此上面的第二个代码不太容易出错。

Else &= 就足够了，因为开发人员希望始终调用 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
======================

因此 YES 我们可以将 && 替换为 & 作为布尔值；-)

所以最好使用 &= 而不是 &&=。

||= 相同

与 &&= 的原因相同：
运算符 |= 比 ||= 更不容易出错。

如果开发人员希望在 f1() 返回 true 时不调用 f2()，那么我建议采用以下替代方案：

// 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 ...

Answer 10

可能是因为像看起来这样的东西

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

应该分配给x并评估someComplexExpression()，但事实上评估取决于值x 从语法上看不出来。

另外，因为 Java 的语法是基于 C 的，所以没有人看到添加这些运算符的迫切需要。无论如何，使用 if 语句可能会更好。

Answer 11

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

现在的问题是为什么在C中是这样，因为当&和&&成为不同的运算符（有时在 C 从 B 继承之前），&= 各种运算符被简单地忽略了。

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

Answer 12

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

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

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