为什么我们通常使用|| 超过|？有什么区别？

我只是想知道为什么我们通常||在两个布尔之间使用逻辑OR 而不是按位OR |，尽管它们都运行良好。

我的意思是，请看以下内容：

if(true  | true)  // pass
if(true  | false) // pass
if(false | true)  // pass
if(false | false) // no pass

if(true  || true)  // pass
if(true  || false) // pass
if(false || true)  // pass
if(false || false) // no pass

我们可以|代替使用||吗？与&和相同&&。

如果使用||和&&形式，而不是这些运算符的|和&形式，则Java不会费心地单独评估右手操作数。

多数情况下，是否要缩短评估是一个问题。

说明短路好处的一个好方法是考虑以下示例。

Boolean b = true;
if(b || foo.timeConsumingCall())
{
   //we entered without calling timeConsumingCall()
}

正如Jeremy和Peter提到的，短路的另一个好处是空引用检查：

if(string != null && string.isEmpty())
{
    //we check for string being null before calling isEmpty()
}

更多信息

| 不对布尔表达式进行短路评估。||将停止评估第一个操作数是否为true，但|不会。

另外，|可用于对字节/短/整数/长数值执行按位或运算。||不能。

因此，仅以其他答案为例，在以下防御性检查中，短路至关重要：

if (foo == null || foo.isClosed()) {
    return;
}

if (bar != null && bar.isBlue()) {
    foo.doSomething();
}

使用|和&可能会导致NullPointerException被抛出此处。

逻辑||并&&仅在必要时检查右侧。该|和&检查两侧每次。

例如：

int i = 12;
if (i == 10 & i < 9) // It will check if i == 10 and if i < 9
...

重写它：

int i = 12;
if (i == 10 && i < 9) // It will check if i == 10 and stop checking afterward because i != 10
...

另一个例子：

int i = 12;
if (i == 12 | i > 10) // It will check if i == 12 and it will check if i > 10
...

重写它：

int i = 12;
if (i == 12 || i > 10) // It will check if i == 12, it does, so it stops checking and executes what is in the if statement
...

还要注意一个常见的陷阱：非惰性运算符的优先级高于惰性运算符，因此：

boolean a, b, c;
a || b && c; //resolves to a || (b && c)
a | b && c; //resolves to (a | b) && c

混合时要小心。

除了短路外，还要记住的另一件事是，对可能不是0或1的值进行按位逻辑运算与条件逻辑的含义非常不同。虽然通常对于|和||，和&和而言是相同的，但&&结果却大不相同（例如2 & 4，0 / false，而2 && 41 / true）。

如果您从函数中获取的内容实际上是错误代码，并且正在测试非零度，那么这可能会非常重要。

在Java中，这不是一个大问题，在Java中，您必须显式地将其类型转换为布尔值或与0或类似值进行比较，但是在其他具有类似语法的语言中（C / C ++等），这可能会造成很大的混乱。

另外，请注意＆和| 仅适用于整数类型的值，不适用于布尔测试的所有值。同样，在非Java语言中，有很多东西可以用作带有隐式!= 0比较的布尔值（指针，浮点数，带有的对象operator bool()等），在这些情况下按位运算符几乎总是无意义的。

只有当您拥有非常简单的布尔表达式并且捷径（例如，一个分支）的开销大于不评估后续表达式而节省的时间时，您才会使用|或&代替||或&&。

但是，这是一个微优化，只有在最底层的代码中才很少发生。

|| 是|时的逻辑或运算符 是按位或运算符。

boolean a = true;
boolean b = false;

if (a || b) {
}

int a = 0x0001;
a = a | 0x0002;

一个| B：在对b求任何情况下，

|| b：仅当 a的值为假时才对b 求值

除了以下事实：是按位运算符：|| 是短路运算符-当一个元素为假时，它将不检查其他元素。

 if(something || someotherthing)
 if(something | someotherthing)

如果为真，|| 不会评估其他内容，而| 会做。如果if语句中的变量实际上是函数调用，请使用|| 可能会节省很多性能。

| is the binary or operator

|| is the logic or operator

这些运算符||和&&称为条件运算符，而|和&称为按位运算符。它们有不同的用途。

条件运算符仅适用boolean于在左侧和右侧均静态求和的表达式。

按位运算符可用于任何数字操作数。

如果要执行逻辑比较，则应使用条件运算符，因为您将在代码中添加某种类型的安全性。

附带说明：Java有| =但没有|| =

何时必须使用||的示例 是第一个表达式是测试以查看第二个表达式是否会崩溃的时间。例如，使用单个| 在以下情况下，可能会导致NPE。

public static boolean isNotSet(String text) {
   return text == null || text.length() == 0;
}

其他答案已经很好地解决了运算符之间的功能差异，但是答案可能适用于当今存在的几乎每种C衍生语言。问题被标记为爪哇，因此我将尽一切努力专门针对Java语言进行回答。

&并且|可以是整数位运算符或布尔逻辑算子。按位和逻辑运算符（第15.22节）的语法为：

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

的语法EqualityExpression中定义§15.21，这需要RelationalExpression在定义§15.20，这又需要ShiftExpression和ReferenceType所定义§15.19和§4.3分别。ShiftExpression要求AdditiveExpression中所定义§15.18，继续向下钻取，限定基本的算术运算，一元运算符等ReferenceType深入到所有不同的方式来表示一个类型。（虽然ReferenceType不包括基本类型，基本类型的定义最终需要的，因为它们可以是用于一个阵列，其尺寸类型是一个ReferenceType）。

按位和逻辑运算符具有以下属性：

• 这些运算符具有不同的优先级，&具有最高优先级和|最低优先级。
• 这些运算符中的每一个在语法上都是左关联的（每个组从左到右）。
• 如果操作数表达式没有副作用，则每个运算符都是可交换的。
• 每个运算符都是关联的。
• 按位和逻辑运算符可用于比较两个数字类型的操作数或两个类型的操作数boolean。所有其他情况都会导致编译时错误。

运算符是按位运算符还是逻辑运算符之间的区别取决于操作数是“可转换为原始整数类型”（第4.2节）还是它们是boolean或类型Boolean（第5.1.8节）。

如果操作数是整数类型，则对两个操作数都执行二进制数值提升（第5.6.2节），而将它们都保留为longs或ints。操作的类型将是（提升的）操作数的类型。此时，&将是按位与，^将是按位异或，并且|将是按位或。（§15.22.1）

如果操作数为booleanor Boolean，则在必要时将对操作数进行拆箱转换（第5.1.8节），并且操作类型为boolean。&将导致true如果两个操作数都是true，^将导致true在两个操作数是不同的，并且|将导致true如果操作数是true。（§15.22.2）

相反， &&是“ Conditional-And运算符”（第15.23节），||是“ Conditional-Or运算符”（第15.24节）。它们的语法定义为：

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&就像一样&，不同的是它仅在左操作数为时评估右操作数true。||就像一样|，不同的是它仅在左操作数为时评估右操作数false。

有条件的-并且具有以下属性：

• 条件和运算符在语法上是左关联的（它从左到右分组）。
• 条件和运算符在副作用和结果值方面是完全相关的。也就是说，对于任何表达式a，b和和c对该表达式的求值都会((a) && (b)) && (c)产生与该表达式的求值相同的结果，并且以相同的顺序发生相同的副作用(a) && ((b) && (c))。
• 条件和运算符的每个操作数必须为boolean或类型Boolean，否则会发生编译时错误。
• 条件和表达式的类型始终为boolean。
• 在运行时，首先对左侧操作数表达式求值；如果结果具有type Boolean，则将其进行拆箱转换（第5.1.8节）。
• 如果结果值为false，则条件和表达式的值为，false并且不计算右侧操作数表达式。
• 如果左侧操作数的值为true，则对右侧表达式求值；否则，将求值。如果结果具有type Boolean，则将其进行拆箱转换（第5.1.8节）。结果值成为条件和表达式的值。
• 因此，&&计算相同的结果&上boolean的操作数。区别仅在于，右侧操作数表达式是有条件而不是始终进行求值的。

条件-或具有以下属性：

• 条件或运算符在语法上是左联想的（它从左到右分组）。
• 条件或运算符在副作用和结果值方面是完全关联的。也就是说，对于任何表达式a，b和和c对该表达式的求值都会((a) || (b)) || (c)产生与该表达式的求值相同的结果，并且以相同的顺序发生相同的副作用(a) || ((b) || (c))。
• 条件或运算符的每个操作数都必须为boolean或类型Boolean，否则会发生编译时错误。
• 条件或表达式的类型始终为boolean。
• 在运行时，首先对左侧操作数表达式求值；如果结果具有type Boolean，则将其进行拆箱转换（第5.1.8节）。
• 如果结果值为true，则条件或表达式的值为，true并且不计算右侧操作数表达式。
• 如果左侧操作数的值为false，则对右侧表达式求值；否则，将求值。如果结果具有type Boolean，则将其进行拆箱转换（第5.1.8节）。结果值成为条件或表达式的值。
• 因此，||计算与|on boolean或Boolean操作数相同的结果。区别仅在于，右侧操作数表达式是有条件而不是始终进行求值的。

总之，作为@JohnMeagher曾多次在评论中指出，&和|，事实上，非短路的操作数是任何的具体情况布尔运算符boolean或Boolean。如果采用良好的做法（即没有次要影响），这是一个很小的差异。但是，当操作数不是booleans或Booleans时，运算符的行为就大不相同了：在Java编程的高级水平上，按位运算和逻辑运算根本无法很好地进行比较。

1）。（表达式1 |表达式2），| 无论expression1的结果是true还是false，运算符都将对expression2求值。

例：

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b | test());
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

2）。（expression1 || expression2），|| 如果expression1为true，则运算符不会计算expression2。

例：

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b || test())
        {
            System.out.println("short circuit!");
        }
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

|| 通过对两个值进行“或”运算来返回布尔值（这就是为什么将其称为LOGICAL或）

IE浏览器：

if (A || B) 

如果A或B为true，则返回true，否则均为false。

| 是对两个值执行按位运算的运算符。为了更好地理解按位运算，可以在这里阅读：

http://en.wikipedia.org/wiki/Bitwise_operation

主要区别在于|| 和&&表现出“短路”，因此仅在需要时才评估RHS。

例如

if (a || b) {
    path1...
} else {
    path2..
}

在上面，如果a为true，则将不测试b并执行path1。如果| 被使用，那么即使'a'为真，也将评估双方。

有关更多信息，请参见此处和此处。

希望这可以帮助。

非短路可能很有用。有时您要确保两个表达式求值。例如，假设您有一个从两个单独的列表中删除对象的方法。您可能想要执行以下操作：

class foo {

    ArrayList<Bar> list1 = new ArrayList<Bar>();
    ArrayList<Bar> list2 = new ArrayList<Bar>();

    //Returns true if bar is removed from both lists, otherwise false.
    boolean removeBar(Bar bar) {
        return (list1.remove(bar) & list2.remove(bar));
    }
}

如果您的方法改用条件操作数，则如果第一个列表返回false，则它将无法从第二个列表中删除对象。

//Fails to execute the second remove if the first returns false.
boolean removeBar(Bar bar) {
    return (list1.remove(bar) && list2.remove(bar));
}

它并不是非常有用，并且（与大多数编程任务一样）您可以通过其他方式实现它。但这是按位操作数的用例。

它们之间的基本区别是| 首先将值转换为二进制，然后执行按位运算。同时|| 不会将数据转换为二进制，而只是对原始状态执行or表达式。

int two = -2; int four = -4;
result = two | four; // bitwise OR example

System.out.println(Integer.toBinaryString(two));
System.out.println(Integer.toBinaryString(four));
System.out.println(Integer.toBinaryString(result));

Output:
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111110

了解更多：http : //javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

当我遇到这个问题时，我创建了测试代码来了解这一点。

public class HelloWorld{

   public static boolean bool(){
      System.out.println("Bool");
      return true;
   }

   public static void main(String []args){

     boolean a = true;
     boolean b = false;

     if(a||bool())
     {
        System.out.println("If condition executed"); 
     }
     else{
         System.out.println("Else condition executed");
     }

 }
}

在这种情况下，我们仅更改if条件添加a或b的左侧值。

|| 场景，当左侧为真时[if（a || bool（））]

输出 "If condition executed"

|| 场景，当左侧为假[if（b || bool（））]

输出-

Bool
If condition executed

Conclusion of || 使用时||，右侧仅检查左侧为false时。

| 场景，当左侧为真时[if（a | bool（））]

输出-

Bool
If condition executed

| 场景，当左侧为假[if（b | bool（））]

输出-

Bool
If condition executed

Conclusion of | 使用时|，请同时检查左右两侧。

| =按位或，|| =逻辑或

通常我在有前递增和后递增运算符时使用。看下面的代码：

package ocjpPractice;
/**
 * @author tithik
 *
 */
public class Ex1 {

    public static void main(String[] args) {
    int i=10;
    int j=9;
    int x=10;
    int y=9;
    if(i==10 | ++i>j){
        System.out.println("it will print in first if");  
        System.out.println("i is: "+i);
    }

    if(x==10 ||++x>y){
        System.out.println("it will print in second if");   
        System.out.println("x is: "+x);
    }
    }
}

输出：

如果
i为：11

将首先打印；如果
x为：10 将第二个打印。

两个if块都相同，但结果不同。如果存在|，将同时评估两个条件。但是，如果为||，则不会评估第二个条件，因为第一个条件已经为真。

有许多用例表明了为什么要去||而不是去|。一些用例必须使用|运算符来检查所有条件。

例如，如果您要检查表单验证，并且想向用户显示所有带有错误文本的无效字段，而不仅仅是第一个无效字段。

|| 运算符是

   if(checkIfEmpty(nameField) || checkIfEmpty(phoneField) || checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

   private boolean checkIfEmpty(Widget field) {
      if(field.isEmpty()) {
        field.setErrorMessage("Should not be empty!");
        return true;
      }
      return false;
   }

因此，使用以上代码段，如果用户提交的表单中包含所有空白字段，则nameField只会显示错误消息。但是，如果将其更改为

   if(checkIfEmpty(nameField) | checkIfEmpty(phoneField) | checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

无论true条件如何，它将在每个字段上显示正确的错误消息。

仔细阅读本主题后，对于|用作逻辑运算符是否符合Java模式惯例的问题，我仍然不清楚。

我最近在请求中的注释中修改了代码，其中

if(function1() | function2()){
  ...
}

必须更改为

boolean isChanged = function1();
isChanged |= function2();
if (isChanged){
  ...
}

实际接受的版本是什么？

Java文档是不提|为一个逻辑非短路或运算。

对投票不感兴趣，但是对找出标准不感兴趣？两种代码版本都可以按预期进行编译和运行。

|| 是逻辑或 是按位或。

Java运算符

| 是按位或，|| 是合乎逻辑的。

看一眼：

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/operators.html

| 按位包含或

|| 是逻辑或

| 是按位运算符。|| 是逻辑运算符。

一个将占用两位或两位。

一个人将确定真相（这个或那个）。如果这是正确的或正确的，那么答案是正确的。

哦，当当的人很快回答了这些问题。