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

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

如果他们使用逻辑与

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

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

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

举个例子:

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

除了&&和||是短路外，在混合这两种形式时，还要考虑运算符优先级。 我认为每个人都不会立即看出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

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

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

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);

然后它会给出一个错误，

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

& <——验证两个操作数 && <——如果第一个操作数求值为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，并执行||。