Java 布尔运算符的差异：&；vs&&；和| vs||_Java_Bitwise Operators_Logical Operators_Boolean Logic

Java 布尔运算符的差异：&；vs&&；和| vs||

java

Java 布尔运算符的差异：&；vs&&；和| vs||,java,bitwise-operators,logical-operators,boolean-logic,Java,Bitwise Operators,Logical Operators,Boolean Logic,我知道&和|的规则，但是&和|是什么？请给我举个例子解释一下。这些是按位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

我知道

和

的规则，但是

和

是什么？请给我举个例子解释一下。

这些是按位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语言规范（，）中指出了关于操作符基于其输入的不同行为的适当部分

事实上，当两个输入都是布尔值时，运算符被视为布尔逻辑运算符，其行为类似于条件and（

&&

）和条件Or（

）运算符，但它们不会短路，因此在以下情况下是安全的：

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

这不是：

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

“短路”是指操作员不必检查所有条件。在上面的示例中，

&&

仅当

不是

null

时才会检查第二个条件（否则整个语句将返回false，并且无论如何检查以下条件都没有意义），因此

a.something

的语句不会引发异常，或者被认为是“安全的”

运算符总是检查子句中的每一个条件，因此在上面的示例中，

实际上是一个

null

值时，可能会计算某个，从而引发异常。

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

和

是整数类型上的位运算符（例如

int

）：

和

仅对布尔运算（和短路，如其他答案所述）。

我想您讨论的是两个运算符的逻辑含义，这里有一个表：

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

，minimal evaluation，或McCarthy evaluation（在John McCarthy之后）是某些编程语言中某些布尔运算符的语义，在这种语言中，仅当第一个参数不足以确定表达式的值时才执行或计算第二个参数：当AND函数的第一个参数计算为false时，总体值必须为false；当OR函数的第一个参数计算为true时，整个值必须为true

不安全表示操作员总是检查子句中的每个条件，因此在上面的示例中，当x实际上是0值时，可以计算1/x，引发异常。

知道按位AND和按位OR运算符总是在条件AND和条件OR之前求值，或者在同一表达式中使用，可能会很有用

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

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

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

如果第一个操作数返回的值为true，则对第二个操作数求值。如果第二个操作数返回的值为true，则将&&运算符应用于第一个和第二个操作数

与|和| |相似。

的基本区别在于，

主要用于

长

、

int

或

字节

上的按位操作，在这些操作中它可以用于某种掩码，即使使用它而不是逻辑的

，结果也可能不同

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

计算某些表达式非常耗时

只有在前一个表达式为真时，才能对其中一个表达式求值

这些表达有一些副作用（有意或无意）

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

关于第二点，请参见此示例：

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

对于

null

，此操作失败，因为计算第二个表达式会生成

NullPointerException

。逻辑运算符

&&

是惰性的，如果左操作数为false，则无论右操作数是什么，结果都为false

第三点的例子——假设我们有一个应用程序使用DB，没有任何触发器或级联。在删除建筑对象之前，必须将部门对象的建筑更改为另一个。也可以说操作状态以布尔值形式返回（true=success）。然后：

这将计算这两个表达式，因此即使部门更新因某种原因失败，也会执行建筑删除。使用

&&

，它可以按预期工作，并在第一次故障后停止

至于

a | | b

，它相当于

！（！a&&！b）

，如果

为真，则停止，无需更多解释。

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

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

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

如果（（a<0）和&（b<0））{…}或类似，如果（（a<0）|（b<0））{…}

来源：java编程语言第四版是逻辑运算符。。。。短路

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

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

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

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

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

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

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