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

除了对两个操作数求值不是一个懒惰的求值器之外，我认为位操作符的主要特征是比较操作数的每个字节，如下例所示:

int a = 4;
int b = 7;
System.out.println(a & b); // prints 4
//meaning in an 32 bit system
// 00000000 00000000 00000000 00000100
// 00000000 00000000 00000000 00000111
// ===================================
// 00000000 00000000 00000000 00000100

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

我想我的答案可以更容易理解:

&和&&之间有两个区别。

如果他们使用逻辑与

&和&&可以是逻辑与，当&或&&左右表达式结果全部为真时，整个运算结果可以为真。

当&和&&作为逻辑与时，有区别:

当使用&&作为逻辑与时，如果左边的表达式结果为假，右边的表达式将不会执行。

举个例子:

String str = null;

if(str!=null && !str.equals("")){  // the right expression will not execute

}

如果使用&:

String str = null;

if(str!=null & !str.equals("")){  // the right expression will execute, and throw the NullPointerException 

}

还有一个例子:

int x = 0;
int y = 2;
if(x==0 & ++y>2){
    System.out.print(“y=”+y);  // print is: y=3
}

int x = 0;
int y = 2;
if(x==0 && ++y>2){
    System.out.print(“y=”+y);  // print is: y=2
}

&可以用作位运算符

&可以用作位与运算符，&&不能。

按位AND“&”运算符当且仅当两个位都在时产生1 它的操作数是1。然而，如果两个比特都是0，或者两个比特都不相同，那么这个运算符产生0。更精确地说，“&”运算符如果两位中的任何一位为1，则返回1，如果其中任何一位为0，则返回0。

来自维基页面:

http://www.roseindia.net/java/master-java/java-bitwise-and.shtml

对于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”操作符。双&号(“&&”)只用于两个布尔参数。

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

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