¿Por qué solemos usar || sobre | ¿Cuál es la diferencia?

Me pregunto por qué usamos OR lógico ||entre dos booleanos, no OR bit a bit |, aunque ambos funcionan bien.

Quiero decir, mira lo siguiente:

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

¿Podemos usar en |lugar de ||? Lo mismo con &y &&.

Si usa los formularios ||y &&, en lugar de los |y& formularios de estos operadores, Java no se molestará en evaluar solo el operando de la derecha.

Es cuestión de si quieres hacer un cortocircuito en la evaluación o no, la mayoría de las veces lo deseas.

Una buena manera de ilustrar los beneficios del cortocircuito sería considerar el siguiente ejemplo.

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

Otro beneficio, como mencionaron Jeremy y Peter, para el cortocircuito es la verificación de referencia nula:

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

más información

| no realiza evaluaciones de cortocircuito en expresiones booleanas. ||dejará de evaluar si el primer operando es verdadero, pero| no lo hará.

Además, |se puede usar para realizar la operación bit-OR en valores de byte / short / int / long. ||no puedo.

Entonces, para construir sobre las otras respuestas con un ejemplo, el cortocircuito es crucial en las siguientes comprobaciones defensivas:

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

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

Usar |y, en &cambio, podría provocar que NullPointerExceptionse arroje aquí.

Lógico ||y &&verifique el lado derecho solo si es necesario. El |y& verifique ambos lados cada vez.

Por ejemplo:

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

Reescribirlo:

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

Otro ejemplo:

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

Reescribirlo:

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
...

Observe también una trampa común: los operadores no perezosos tienen prioridad sobre los flojos, por lo que:

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

Tenga cuidado al mezclarlos.

Además del cortocircuito, otra cosa a tener en cuenta es que realizar una operación lógica bit a bit en valores que pueden ser distintos de 0 o 1 tiene un significado muy diferente al de la lógica condicional. Si bien generalmente es lo mismo para |y ||, con &y &&obtiene resultados muy diferentes (por ejemplo, 2 & 4es 0 / falso mientras2 && 4 es 1 / verdadero).

Si lo que obtienes de una función es en realidad un código de error y estás probando que no es 0, esto puede ser bastante importante.

Este no es un problema tan grande en Java donde tiene que escribir explícitamente en booleano o comparar con 0 o similar, pero en otros lenguajes con una sintaxis similar (C / C ++ et al) puede ser bastante confuso.

Además, tenga en cuenta que & y | solo puede aplicarse a valores de tipo entero, y no todo lo que puede ser equivalente a una prueba booleana. Nuevamente, en lenguajes que no son Java, hay bastantes cosas que se pueden usar como booleanos con una != 0comparación implícita (punteros, flotantes, objetos con un operator bool(), etc.) y los operadores bit a bit casi siempre no tienen sentido en esos contextos.

La única vez que usaría |o en &lugar de ||o&& es cuando tiene expresiones booleanas muy simples y el costo del atajo (es decir, una rama) es mayor que el tiempo que ahorra al no evaluar las expresiones posteriores.

Sin embargo, esta es una microoptimización que rara vez importa, excepto en el código de nivel más bajo.

|| es el lógico u operador mientras | es el bit a bit u operador.

boolean a = true;
boolean b = false;

if (a || b) {
}

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

a | b: evaluar b en cualquier caso

a || b: evalúe b solo si a se evalúa como falso

Además del hecho de que | es un operador bit a bit: || es un operador de cortocircuito: cuando un elemento es falso, no verificará los otros.

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

si algo es VERDADERO || no evaluará otra cosa, mientras que | lo haré Si las variables en sus declaraciones if son en realidad llamadas a funciones, usando || posiblemente está ahorrando mucho rendimiento.

| is the binary or operator

|| is the logic or operator

Los operadores ||y &&se llaman operadores condicionales , mientras que |y &se llaman operadores bit a bit . Sirven para diferentes propósitos.

Los operadores condicionales solo funcionan con expresiones que evalúan estáticamente booleantanto en el lado izquierdo como en el derecho.

Los operadores bit a bit funcionan con cualquier operando numérico.

Si desea realizar una comparación lógica, debe usar operadores condicionales , ya que agregará algún tipo de seguridad de tipo a su código.

Una nota al margen: Java tiene | = pero no un || =

Un ejemplo de cuándo debes usar || es cuando la primera expresión es una prueba para ver si la segunda expresión explotaría. por ejemplo, usando un solo | en el siguiente caso podría resultar en un NPE.

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

Las otras respuestas han hecho un buen trabajo al cubrir la diferencia funcional entre los operadores, pero las respuestas podrían aplicarse a casi todos los lenguajes derivados de C que existen en la actualidad. La pregunta está etiquetada conJava, por lo que me esforzaré por responder específica y técnicamente para el lenguaje Java.

&y |pueden ser operadores enteros a nivel de bit u operadores lógicos booleanos. La sintaxis para los operadores lógicos y a nivel de bits ( §15.22 ) es:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

La sintaxis para EqualityExpressionse define en §15.21 , que requiere RelationalExpressiondefinido en §15.20 , que a su vez requiere ShiftExpressiony ReferenceTypedefinido en §15.19 y §4.3 , respectivamente. ShiftExpressionrequiere AdditiveExpressiondefinido en §15.18 , que continúa profundizando, definiendo la aritmética básica, operadores unarios, etc. ReferenceTypeprofundiza en todas las diversas formas de representar un tipo. (Si bien ReferenceTypeno incluye los tipos primitivos, la definición de los tipos primitivos se requiere en última instancia, ya que pueden ser el tipo de dimensión para una matriz, que es a ReferenceType.)

Los operadores lógicos y a nivel de bit tienen las siguientes propiedades:

• Estos operadores tienen precedencia diferente, con &la precedencia más alta y |la precedencia más baja.
• Cada uno de estos operadores es sintácticamente asociativo a la izquierda (cada grupo se agrupa de izquierda a derecha).
• Cada operador es conmutativo si las expresiones de operando no tienen efectos secundarios.
• Cada operador es asociativo.
• Los operadores lógicos y de bits pueden usarse para comparar dos operandos de tipo numérico o dos operandos de tipo boolean. Todos los demás casos dan como resultado un error en tiempo de compilación.

La distinción entre si el operador sirve como operador bit a bit o como operador lógico depende de si los operandos son "convertibles a un tipo integral primitivo" ( §4.2 ) o si son de tipos booleano Boolean( §5.1.8 ).

Si los operandos son tipos integrales, promoción numérica binaria ( §5.6.2 ) se lleva a cabo en los dos operandos, dejando a los dos, ya sea como longs o ints para la operación. El tipo de la operación será el tipo de los operandos (promocionados). En ese punto, &será bit a bit AND, ^será bit a bit exclusivo, y |será bit a bit inclusivo. ( §15.22.1 )

Si los operandos son booleano Boolean, los operandos estarán sujetos a la conversión de unboxing si es necesario ( §5.1.8 ), y el tipo de operación será boolean. &dará como resultado truesi ambos operandos son true, ^dará como resultado truesi ambos operandos son diferentes, y |dará como resultado truesi cualquiera de los operandos es true. ( §15.22.2 )

Por el contrario, && es el "Operador condicional y" ( §15.23 ) y ||es el "Operador condicional u" ( §15.24 ). Su sintaxis se define como:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&es como &, excepto que solo evalúa el operando derecho si el operando izquierdo es true. ||es como |, excepto que solo evalúa el operando derecho si el operando izquierdo es false.

Condicional-Y tiene las siguientes propiedades:

• El operador condicional y es sintácticamente asociativo a la izquierda (agrupa de izquierda a derecha).
• El operador condicional y es totalmente asociativo con respecto a los efectos secundarios y al valor del resultado. Es decir, para cualquier expresión a, by c, la evaluación de la expresión ((a) && (b)) && (c)produce el mismo resultado, con los mismos efectos secundarios que ocurren en el mismo orden, que la evaluación de la expresión (a) && ((b) && (c)).
• Cada operando del operador condicional y debe ser de tipo booleano Boolean, o se produce un error en tiempo de compilación.
• El tipo de condicional y expresión es siempre boolean.
• En tiempo de ejecución, la expresión del operando de la izquierda se evalúa primero; si el resultado tiene tipo Boolean, está sujeto a la conversión de unboxing ( §5.1.8 ).
• Si el valor resultante es false, el valor de condicional y expresión es falsey la expresión de operando de la derecha no se evalúa.
• Si el valor del operando de la izquierda es true, entonces se evalúa la expresión de la derecha; si el resultado tiene tipo Boolean, está sujeto a la conversión de unboxing ( §5.1.8 ). El valor resultante se convierte en el valor de condicional y expresión.
• Por lo tanto, &&calcula el mismo resultado que &en los booleanoperandos. Solo difiere en que la expresión del operando de la derecha se evalúa condicionalmente en lugar de siempre.

Condicional-Or tiene las siguientes propiedades:

• El operador condicional u es sintácticamente asociativo a la izquierda (agrupa de izquierda a derecha).
• El operador condicional u es totalmente asociativo con respecto a los efectos secundarios y al valor del resultado. Es decir, para cualquier expresión a, by c, la evaluación de la expresión ((a) || (b)) || (c)produce el mismo resultado, con los mismos efectos secundarios que ocurren en el mismo orden, que la evaluación de la expresión (a) || ((b) || (c)).
• Cada operando del condicional-u operador debe ser de tipo booleano Boolean, o se produce un error en tiempo de compilación.
• El tipo de una condicional-o expresión es siempre boolean.
• En tiempo de ejecución, la expresión del operando de la izquierda se evalúa primero; si el resultado tiene tipoBoolean, está sujeto a la conversión de unboxing ( §5.1.8 ).
• Si el valor resultante es true , el valor de la expresión condicional o es truey la expresión del operando de la derecha no se evalúa.
• Si el valor del operando de la izquierda es false, entonces se evalúa la expresión de la derecha; si el resultado tiene tipoBoolean , está sujeto a la conversión de unboxing ( §5.1.8 ). El valor resultante se convierte en el valor de la condicional o expresión.
• Por lo tanto, ||calcula el mismo resultado que |en booleanoBoolean operandos. Solo difiere en que la expresión del operando de la derecha se evalúa condicionalmente en lugar de siempre.

En resumen, como @JohnMeagher ha señalado repetidamente en los comentarios, &y |son, de hecho, operadores booleanos sin cortocircuito en el caso específico de que los operandos sean booleano Boolean. Con buenas prácticas (es decir: sin efectos secundarios), esta es una diferencia menor. Sin embargo, cuando los operandos no son booleans o Booleans, los operadores se comportan de manera muy diferente: las operaciones bit a bit y lógicas simplemente no se comparan bien en el alto nivel de programación Java.

1). (Expresión1 | expresión2), | El operador evaluará la expresión2 independientemente de si el resultado de la expresión1 es verdadero o falso.

Ejemplo:

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). (Expresión1 || expresión2), || El operador no evaluará la expresión2 si la expresión1 es verdadera.

Ejemplo:

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

|| devuelve un valor booleano OR con dos valores (es por eso que se conoce como LÓGICO o)

ES DECIR:

if (A || B) 

Devuelve verdadero si A o B es verdadero, o falso si ambos son falsos.

El | es un operador que realiza una operación bit a bit en dos valores. Para comprender mejor las operaciones bit a bit, puede leer aquí:

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

Una diferencia principal es que || y && exhiben "cortocircuito", por lo que el RHS solo se evaluará si es necesario.

Por ej.

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

Arriba, si a es verdadero, entonces b no se probará y se ejecutará path1. Si | se usó, entonces ambos lados serían evaluados incluso si 'a' es verdadero.

Mira aquí y aquí , para un poco más de información.

Espero que esto ayude.

No cortocircuito puede ser útil. A veces quieres asegurarte de que dos expresiones evalúen. Por ejemplo, supongamos que tiene un método que elimina un objeto de dos listas separadas. Es posible que desee hacer algo como esto:

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

Si su método utilizara el operando condicional, no podría eliminar el objeto de la segunda lista si la primera lista devuelve falso.

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

No es sorprendentemente útil, y (como con la mayoría de las tareas de programación) podría lograrlo con otros medios. Pero es un caso de uso para operandos bit a bit.

La diferencia básica entre ellos es que | primero convierte los valores a binario y luego realiza el bit sabio u operación. Mientras tanto, || no convierte los datos en binario y solo realiza la expresión o en su estado original.

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

Leer más: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

Cuando tuve esta pregunta, creé el código de prueba para tener una idea al respecto.

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

 }
}

En este caso, solo cambiamos el valor del lado izquierdo de si la condición agrega a o b.

|| Escenario, cuando el lado izquierdo es verdadero [if (a || bool ())]

salida "If condition executed"

|| Escenario, cuando el lado izquierdo es falso [if (b || bool ())]

Salida-

Bool
If condition executed

Conclusion of || Cuando se usa ||, el lado derecho solo verifica cuando el lado izquierdo es falso.

| Escenario, cuando el lado izquierdo es verdadero [if (a | bool ())]

Salida-

Bool
If condition executed

| Escenario, cuando el lado izquierdo es falso [if (b | bool ())]

Salida-

Bool
If condition executed

Conclusion of | Cuando lo use |, verifique los lados izquierdo y derecho.

El | = bit a bit o, || = lógica o

generalmente lo uso cuando hay un operador de incremento previo y posterior. Mira el siguiente código:

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

salida:

se imprimirá primero si
yo es: 11

se imprimirá en segundo lugar si
x es: 10

ambos ifbloques son iguales pero el resultado es diferente. cuando exista |, ambas condiciones serán evaluadas. Pero si es ||así, no evaluará la segunda condición, ya que la primera condición ya es verdadera.

Hay muchos casos de uso que sugieren por qué debería ir en ||lugar de hacerlo |. Algunos casos de uso tienen que usar el |operador para verificar todas las condiciones.

Por ejemplo, si desea verificar la validación del formulario y desea mostrar al usuario todos los campos no válidos con textos de error en lugar de solo un primer campo no válido.

|| operador sería,

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

Entonces, con el fragmento anterior, si el usuario envía el formulario con TODOS los campos vacíos, SOLO nameFieldse mostrará con un mensaje de error. Pero, si lo cambias a,

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

Mostrará un mensaje de error apropiado en cada campo, independientemente de las truecondiciones.

Después de leer detenidamente este tema todavía no me queda claro si usarlo |como operador lógico es conforme a las prácticas de patrones Java.

Recientemente modifiqué el código en una solicitud de extracción que aborda un comentario donde

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

tuvo que ser cambiado a

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

¿Cuál es la versión real aceptada?

La documentación de Java no se menciona |como un operador OR lógico sin cortocircuito.

¿No está interesado en una votación pero más en descubrir el estándar? Ambas versiones de código están compilando y funcionando como se esperaba

|| es un lógico oy | es un poco sabio o.

Operadores de Java

El | es bit a bit o || es lógico o

Echa un vistazo a:

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

El | es bit a bit inclusivo O

|| es lógico O

El | es un operador bit a bit. || Es un operador lógico.

Uno tomará dos bits y / o ellos.

Uno determinará la verdad (esto O aquello) Si esto es cierto o es cierto, entonces la respuesta es verdadera.

Ah, y dang personas responden estas preguntas rápidamente.