& <——验证两个操作数 && <——如果第一个操作数求值为false，则停止求值，因为结果将为false

(x != 0) & (1/x > 1) <——这意味着求(x != 0)然后求(1/x > 1)然后执行&。问题是当x=0时，这会抛出异常。

(x != 0) && (1/x > 1) <——这意味着求(x != 0)，只有当它为真时，才求(1/x > 1)，所以如果你有x=0，那么这是完全安全的，并且不会抛出任何异常，如果(x != 0)求值为假，整个事情直接求值为假，而不求(1/x > 1)。

编辑:

exprA | exprB <——这意味着评估exprA然后评估exprB，然后执行|。

exprA || exprB <——这意味着评估exprA，只有当这是假的，然后评估exprB，并执行||。

除了&&和||是短路外，在混合这两种形式时，还要考虑运算符优先级。 我认为每个人都不会立即看出result1和result2包含不同的值。

boolean a = true;
boolean b = false;
boolean c = false;

boolean result1 = a || b && c; //is true;  evaluated as a || (b && c)
boolean result2 = a  | b && c; //is false; evaluated as (a | b) && c

&&是短路运算符，而&是与运算符。

试试这个。

    String s = null;
    boolean b = false & s.isEmpty(); // NullPointerException
    boolean sb = false && s.isEmpty(); // sb is false

几乎所有的答案都很好地涵盖了每一个比较点。我只想再举一个例子。以演示输出如何根据所使用的操作符而变化。考虑下面的例子

int a = 10;
if(++a==10 & ++a==12) {
    ++a;
}
System.out.println(a); //12

在上面的代码中，我们使用了按位&运算符。因此，它将计算两个参数(左和右)，而不考虑单个结果。

所以a会在if条件内增加2倍。但是由于条件不会变为true，它不会进入if循环内部，第三个增量也不会发生。所以a的最终值在这里是12。

现在假设，在上面的同一个例子中，如果我们使用短路&&运算符。然后在将++a==10赋值为false后，它将不会去检查第二个参数。这就是未来11人的最终价值。

int a = 10;
if(++a==10 && ++a==12) {
    ++a;
}
System.out.println(a); //11

基于此，我们可以说，与短路&&算子相比，位&算子的性能相对较低。位运算符将对两个参数求值，而不考虑第一个参数的结果。而&&运算符将停止计算第二个参数，如果第一个参数的结果为假。

这两者之间的另一个区别是，Bitwise &操作符适用于布尔型以及整型。而短路&&运算符仅适用于布尔类型。

我们可以写

System.out.println(4 & 5); // 4

但如果我们试着这样写，

System.out.println(4 && 5);

然后它会给出一个错误，

二元运算符'&&'的错误操作数类型

对于AND运算符和OR运算符，Java有两类求值，即Short-Circuit求值和full求值。

&& ||短路评估

短路求值使您可以不计算AND和OR表达式的右边，当整体结果可以从左边的值预测时。

int numberOne = 1;
int numberTwo = 2;
boolean result = false;

// left-side is false so the the overall result CAN be predicted without evaluating the right side.
// numberOne will be 1, numberTwo will be 2, result will be false
result = (numberOne > numberTwo) && (++numberOne == numberTwo);

System.out.println(numberOne); // prints 1
System.out.println(numberTwo); // prints 2
System.out.println(result);    // prints false


// left-side is true so the the overall result CAN NOT be predicted without evaluating the right side.
// numberOne will be 2, numberTwo will be 2, result will be true
result = (numberTwo > numberOne) && (++numberOne == numberTwo);

System.out.println(numberOne); // prints 2
System.out.println(numberTwo); // prints 2
System.out.println(result);    // prints true

^全面评估

虽然在某些情况下可以预测结果，但有必要计算右边的值。

int numberOne = 1;
int numberTwo = 2;
boolean result = false;

// left-side is false so the the overall result will be false BUT the right side MUST be evaluated too.
// numberOne will be 2, numberTwo will be 2, result will be false
result = (numberOne > numberTwo) & (++numberOne == numberTwo);

System.out.println(numberOne); // prints 2
System.out.println(numberTwo); // prints 2
System.out.println(result);    // prints false

注意:

Notice that for XOR (^) there is no short-circuit, because both sides are always required to determine the overall result. Notice that other possible names for Short-Circuit evaluation are minimal evaluation and McCarthy evaluation. It is not recommenced to mix boolean logic and actions in the same expression & can also act as a Bitwise AND operator which is very academic and can be used in cryptography. When both bits are 1, the result is 1, or either of the bits is not 1, the result is 0. (Check the following code)

AND位的例子:

byte a = 5;              // 00000101
byte b = 3;              // 00000011
byte c = (byte) (a & b); // 00000001 (c is 1)

这取决于参数的类型……

对于整数参数，单个&号(“&”)是“逐位AND”操作符。双&号(“&&”)只用于两个布尔参数。

对于布尔参数，单个&号构成(无条件)“逻辑与”运算符，而双&号(“&&”)是“条件逻辑与”运算符。也就是说，单&号总是计算两个参数，而双&号只在第一个参数为真时计算第二个参数。

对于所有其他参数类型和组合，应该发生编译时错误。