布尔运算符的差异：&与&&和 |与||

Question

我知道 && 和 || 的规则，但是 & 和 | 是什么？请用例子向我解释这些。

Answer 1

这些是按位 AND 和按位 OR 运算符。

int a = 6; // 110
int b = 4; // 100

// Bitwise AND    

int c = a & b;
//   110
// & 100
// -----
//   100

// Bitwise OR

int d = a | b;
//   110
// | 100
// -----
//   110

System.out.println(c); // 4
System.out.println(d); // 6

感谢 Carlos 指出 Java 语言规范中的相应部分 (15.22.1，15.22.2) 关于操作员基于其输入的不同行为。

事实上，当两个输入都是布尔值时，运算符被视为布尔逻辑运算符，其行为类似于条件与 (&&) 和条件或 (||) ) 运算符，除了它们不会短路这一事实，因此，虽然以下情况是安全的：

if((a != null) && (a.something == 3)){
}

这不是：

if((a != null) & (a.something == 3)){
}

“短路”意味着运算符不一定检查所有条件。在上面的示例中，仅当 a 不为 null 时，&& 才会检查第二个条件（否则整个语句将返回 false，并且无论如何检查以下条件都是没有意义的），因此 a.something 的语句不会引发异常，或者被认为是“安全的”。

& 运算符始终检查子句中的每个条件，因此在上面的示例中，当 a 实际上是时，可能会计算 a.something null 值，引发异常。

Answer 2

我认为您正在谈论两个运算符的逻辑含义，这里您有一个表格简历：

boolean a, b;

Operation     Meaning                       Note
---------     -------                       ----
   a && b     logical AND                    short-circuiting
   a || b     logical OR                     short-circuiting
   a &  b     boolean logical AND            not short-circuiting
   a |  b     boolean logical OR             not short-circuiting
   a ^  b     boolean logical exclusive OR
  !a          logical NOT

short-circuiting        (x != 0) && (1/x > 1)   SAFE
not short-circuiting    (x != 0) &  (1/x > 1)   NOT SAFE

<短路求值、最小求值或麦卡锡求值（以约翰·麦卡锡命名）是某些编程语言中某些布尔运算符的语义，其中只有第一个参数才执行或求值第二个参数参数不足以确定表达式的值：当 AND 函数的第一个参数计算结果为 false 时，整体值必须为 false；当 OR 函数的第一个参数计算结果为 true 时，整体值也必须为 true。

不安全意味着运算符始终检查子句中的每个条件，因此在上面的示例中，当 x 实际上是 0 值时，可能会计算 1/x，从而引发异常。

Answer 3

我知道这里有很多答案，但它们似乎都有点令人困惑。因此，在对 Java oracle 学习指南进行了一些研究之后，我提出了何时使用 && 的三种不同场景。或&。
这三种情况是逻辑与、按位与和布尔与。

逻辑与：
逻辑 AND（又名条件 AND）使用 && 运算符。它的短路含义是：如果左操作数为 false，则不会评估右操作数。
示例：

int x = 0;
if (false && (1 == ++x) {
    System.out.println("Inside of if");
}
System.out.println(x); // "0"

在上面的示例中，打印到 x 控制台的值将为 0，因为 if 语句中的第一个操作数为 false，因此 java 不需要计算 (1 == ++x) 因此 x 将不被计算。

按位与：
按位 AND 使用 & 运算符。它用于对值执行按位运算。通过查看二进制数的运算，可以更容易地了解发生了什么，例如：

int a = 5;     //                    5 in binary is 0101
int b = 12;    //                   12 in binary is 1100
int c = a & b; // bitwise & preformed on a and b is 0100 which is 4

正如您在示例中看到的，当数字 5 和 12 的二进制表示形式排成一行时，执行按位 AND 只会产生一个二进制数其中两个数字中的相同数字都是 1。因此 0101 & 1100 == 0100。十进制表示为 5 & 1100 == 0100。 12 == 4。

布尔与：
现在，布尔 AND 运算符的行为与按位 AND 和逻辑 AND 类似，但也有不同。我喜欢将其视为在两个布尔值（或位）之间执行按位 AND，因此它使用 & 运算符。布尔值也可以是逻辑表达式的结果。

它返回 true 或 false 值，与逻辑 AND 非常相似，但与逻辑 AND 不同的是，它不是短路的。原因是，为了执行按位 AND，它必须知道左操作数和右操作数的值。这是一个例子：

int x = 0;
if (false & (1 == ++x) {
    System.out.println("Inside of if");
}
System.out.println(x); //"1"

现在，当运行 if 语句时，即使左操作数为 false，表达式 (1 == ++x) 也会被执行。因此 x 打印出来的值将是 1，因为它是递增的。

这也适用于逻辑 OR (||)、按位 OR (|) 和布尔 OR (|)
希望这能消除一些困惑。

Answer 4

运营商 &&和||是短路的，这意味着如果左侧表达式的值足以确定结果，它们将不会计算右侧表达式。

Answer 5

&和 |提供与 && 相同的结果和||运营商。不同之处在于它们总是评估表达式的两边，其中 as &&和||停止评估第一个条件是否足以确定结果。

Answer 6

在 Java 中，单个运算符 &、|、^、!取决于操作数。如果两个操作数都是整数，则执行按位运算。如果两者都是布尔值，则执行“逻辑”运算。

如果两个操作数不匹配，则会引发编译时错误。

双运算符 &&、||其行为与单个操作数类似，但两个操作数都必须是条件表达式，例如：

if (( a < 0 ) && ( b < 0 )) { ... } 或类似的，
if (( a < 0 ) || ( b < 0 )) { ... }

来源：java 编程语言第 4 版

Answer 7

& 和 | 是整型上的按位运算符（例如 int）： http://download.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

&& ; 和 || 仅对布尔值进行操作（并且短路，正如其他答案已经说过的那样）。

Answer 8

也许知道按位 AND 和按位 OR 运算符总是在同一表达式中使用条件 AND 和条件 OR 之前计算会很有用。

if ( (1>2) && (2>1) | true) // false!

Answer 9

&& ; ||是逻辑运算符....短路

& ; |是布尔逻辑运算符...非短路

转向表达式执行的差异。位运算符对两边进行计算，而不管左边的结果如何。但在使用逻辑运算符计算表达式的情况下，右侧表达式的计算取决于左侧条件。

例如：

int i = 25;
int j = 25;
if(i++ < 0 && j++ > 0)
    System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);

这将打印 i=26 ； j=25，由于第一个条件为假，因此无论右侧条件如何，结果都是假，因此右侧条件被绕过。（短路）

int i = 25;
int j = 25;
if(i++ < 0 & j++ > 0)
    System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);

但是，这将打印 i=26; j=26，

Answer 10

如果计算涉及布尔 & 运算符的表达式，则会计算两个操作数。然后&运算符应用于操作数。

当计算涉及 && 运算符的表达式时，将计算第一个操作数。如果第一个操作数的计算结果为 false，则跳过第二个操作数的计算。

如果第一个操作数返回 true 值，则计算第二个操作数。如果第二个操作数返回 true 值，则 &&然后将运算符应用于第一和第二操作数。

类似 |和||。

Answer 11

虽然基本区别在于 & 主要用于 long、int 或 byte 上的按位运算，其中可用于某种掩码，即使您使用它而不是逻辑 &&，结果也可能有所不同。

在某些情况下，差异更为明显：

1. 计算某些表达式非常耗时
2. 仅当前一个表达式为 true 时才能计算其中一个表达式
3. 表达式有一些副作用（有意或无意）

第一点非常简单，它不会导致错误，但需要更多时间。如果一个条件语句中有多个不同的检查，请将那些成本较低或更有可能失败的检查放在左侧。

对于第二点，请参阅此示例：

if ((a != null) & (a.isEmpty()))

对于 null 失败，因为计算第二个表达式会产生 NullPointerException。逻辑运算符&&是惰性运算符，如果左操作数为假，则无论右操作数是什么，结果都是假。

第三点的示例 - 假设我们有一个使用数据库的应用程序，没有任何触发器或级联。在删除建筑物对象之前，我们必须将部门对象的建筑物更改为另一栋。我们还假设操作状态以布尔值形式返回（true = 成功）。然后：

if (departmentDao.update(department, newBuilding) & buildingDao.remove(building))

这会计算两个表达式，从而执行建筑物拆除，即使部门更新由于某种原因失败。使用 && 时，它会按预期工作，并在第一次失败后停止。

至于 a || b，相当于!(!a && !b)，如果a为true则停止，无需更多解释。