&和,,在Java中?

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

这取决于参数的类型……

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

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

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

,,是短路运算符，而&是AND运算符。

试试这个。

    String s = null;
boolean b = false & s.isEmpty(); // NullPointerException
boolean sb = false && s.isEmpty(); // sb is 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，只有当这是false时，才求值exprB并执行||。

它在JLS (15.22.2)中指定:

当&， ^或|操作符的两个操作数都是布尔类型或布尔类型时，则按位操作符表达式的类型为布尔类型。在所有情况下，操作数都需要进行开箱转换(§5.1.8)。

对于&，如果两个操作数值都为真，则结果值为真;否则，结果为假。

对于^，如果操作数值不同，则结果值为真;否则，结果为假。

对于|，如果两个操作数值都为假，则结果值为假;否则，结果为真。

“trick"&既是整位运算符也是布尔逻辑运算符。所以为什么不呢，把这个作为操作符重载的例子是合理的。

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

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

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

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

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 = 1时，编写表达式(a != 0) && ( b != 0)，会发生以下情况:

a != 0 -->false
expression returns false

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

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

例如:- Condition1 &&Condition2

如果Condition1为false，则(Condition1 &&条件2)总是为假，这就是为什么这个逻辑运算符也被称为短路运算符的原因，因为它不计算另一个条件。如果条件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

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

因此，在本例中，如果a为true，变量x将不会增加。

所有的答案都是great，似乎no更多的答案是is needed 但我只是想指出一些关于&&操作符的东西，称为dependent condition

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

在这种情况下，依赖条件应该放在&&操作符防止错误。

考虑表达式(i != 0) && (10 / i == 2)。依赖条件(10 / i == 2)必须appear after &&操作符，以防止被0除的可能性。

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

还有一件事:&&和||被称为短路的评估，因为第二个参数被执行或求值only if， first参数执行not suffice到determine，即expression的value

引用:Java™如何编程(早期对象)，第十版

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

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

如果他们使用逻辑与

&和&&可以是逻辑上的AND，当&或&&左右表达式结果都为真时，整个运算结果可以为真。

当&和&&作为逻辑AND时，有一个区别:

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

举个例子:

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操作符，而&&不能。

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

来自维基页面:

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

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

对于AND和OR操作符，Java有两种类型的求值，即Short-Circuit evaluation和full evaluation。

&& ||短路评估

短路的评估允许你不评价 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

注意:

1. 注意，对于XOR (^)，没有短路，因为总是需要两边来确定总体结果。
2. 注意，短路计算的其他可能名称是minimal evaluation和McCarthy evaluation。
3. 在同一个表达式中不再混合布尔逻辑和操作
4. &也可以作为一个Bitwise AND操作符，这是非常学术的，可用于密码学。当两个比特都为1时，结果为1，或者其中一个比特不为1时，结果为0。(检查以下代码)

AND位的例子:

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

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

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

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

因此，a将在if condition内增加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);

然后它会给出一个错误，

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