&&和||称为短路算子。当使用它们时，对于|| -如果第一个操作数求值为true，则其余操作数不求值。对于&& -，如果第一个操作数求值为false，其余的操作数根本不被求值。

所以if (a || (++x > 0))在这个例子中，如果a为真，变量x不会增加。

' && ': -是一个逻辑与运算符，根据其参数的逻辑关系产生一个布尔值true或false。

例如:—Condition1 && Condition2

如果Condition1为假，那么(Condition1 && Condition2)将始终为假，这就是为什么这个逻辑运算符也被称为短路运算符的原因，因为它不计算另一个条件。如果条件1为假，则不需要计算条件2。

如果条件1为真，则评估条件2，如果它为真，则总体结果为真，否则为假。

' & ': -是位与运算符。如果两个输入位都为1，则在输出中产生1(1)。否则产生0(0)。

例如:-

int = 12;// 12的二进制表示是1100

int b = 6;// 6的二进制表示是0110

Int c=(a & b);//(12 & 6)的二进制表示为0100

c是4。

如需参考，请参阅http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

对于布尔值，两者之间没有输出差异。你可以交换&&和&或||和|，它永远不会改变表达式的结果。

区别在于处理信息的场景背后。当你对a= 0和b = 1的表达式“(a != 0) & (b != 0)”进行右转时，会发生以下情况:

left side: a != 0 --> false
right side: b 1= 0 --> true
left side and right side are both true? --> false
expression returns false

当你写一个表达式(a != 0) && (b != 0)当a= 0和b = 1时，会发生以下情况:

a != 0 -->false
expression returns false

更少的步骤，更少的处理，更好的编码，特别是在处理许多布尔表达式或复杂的参数时。

对于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)

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

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

如果他们使用逻辑与

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

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

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

举个例子:

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

所有的答案都很棒，似乎不需要更多的答案了 但我只是想指出关于&&算子的一些东西，叫做依赖条件

在使用运算符&&的表达式中，一个条件——我们称之为依赖条件——可能需要另一个条件为真，以使依赖条件的求值有意义。

在这种情况下，依赖条件应该放在&&运算符之后以防止错误。

考虑表达式(i != 0) && (10 / i == 2)。依赖条件(10 / i == 2)必须出现在&&运算符之后，以防止被零除的可能性。

另一个例子(myObject != null) && (myObject. getvalue () == somevaluse)

还有一件事:&&和||被称为短路求值，因为只有当第一个参数不足以确定表达式的值时，才会执行或求值第二个参数

参考资料:Java™如何编程(早期对象)，第十版