¿Hay alguna diferencia entre usar un operador lógico o un operador bit a bit en un bloque if en Java?

Question

El contenido de ambos de los siguientes si los bloques deben ser ejecutadas:

if(booleanFunction() || otherBooleanFunction()) {...} 
if(booleanFunction() | otherBooleanFunction()) {...} 

Entonces, ¿cuál es la diferencia entre usar o usar |||?

Nota: Miré esto y encontré mi propia respuesta, que incluí a continuación. Por favor, siéntete libre de corregirme o dar tu propia opinión. ¡Seguro que hay margen de mejora!

Answer 1

El operador lógico funciona en booleanos, y el operador bit a bit trabaja en bits. En este caso, el efecto va a ser la misma, pero hay dos diferencias:

1. El operador de bits no es para eso, lo que hace que sea más difícil de leer, pero lo más importante
2. El operador lógico OR evaluará la primera condición. Si es verdad, no importa lo que los próximos condición da lugar, el resultado será cierto, por lo la segunda cláusula no se ejecuta

Aquí hay un código útil para probar esto:

public class OperatorTest { 

    public static void main(String[] args){ 
     System.out.println("Logical Operator:"); 
     if(sayAndReturn(true, "first") || sayAndReturn(true, "second")){ 
      //doNothing 
     } 

     System.out.println("Bitwise Operator:"); 
     if(sayAndReturn(true, "first") | sayAndReturn(true, "second")){ 
      //doNothing 
     } 
    } 

    public static boolean sayAndReturn(boolean ret, String msg){ 
     System.out.println(msg); 
     return ret; 
    } 
} 

Answer 2

Los dos tienen diferentes usos. Aunque en muchos casos (cuando se trata de booleanos) puede parecer que tienen el mismo efecto, es importante tener en cuenta que el OR lógico es un cortocircuito, lo que significa que si su primer argumento se evalúa como verdadero, entonces el segundo argumento queda no evaluado El operador bit a bit evalúa ambos argumentos independientemente.

De forma similar, el AND lógico es un cortocircuito, lo que significa que si su primer argumento se evalúa como falso, el segundo no se evalúa. Nuevamente, el bit-AND no lo es.

Esto se puede ver en acción aquí:

int x = 0; 
int y = 1; 
System.out.println(x+y == 1 || y/x == 1); 
System.out.println(x+y == 1 | y/x == 1); 

La primera sentencia print funciona bien y devuelve cierto, ya que el primer argumento se evalúa como verdadera, y por lo tanto deja de evaluación. El segundo error de declaración de impresión ya que no es un cortocircuito, y se encuentra una división por cero.

Answer 3

if(booleanFunction() || otherBooleanFunction()) {...} 

En esta condición si booleanFunction() vuelve true continuación otherBooleanFunction() no serían ejecutados.

if(booleanFunction() | otherBooleanFunction()) {...} 

Pero operador de bits en ambas funciones - booleanFunction() y otherBooleanFunction() serían ejecutados sin importar booleanFunction() vuelve true o false

Answer 4

para los programadores, sólo hay una diferencia.

1. sus operadores lógicos son lógicos, es decir. prueban solo una condición y obtienen resultados basados ​​en eso.

booleanFunction() || otherBooleanFunction() será verdadero si alguno es verdadero. del mismo modo, booleanFunction() & & otherBooleanFunction() será falso si alguno de ellos es falso. Entonces, ¿por qué probar el otro? eso es lo que hacen los operadores lógicos.

Pero los bit a bit verifican ambos. Una aplicación frecuente de este concepto es la siguiente.

if(someObject != null && someObject.somemethod()) 

Por lo tanto, en este caso, si se reemplaza por &&& luego esperar a que un desastre. Obtendrá NullPointerException desagradable pronto ...

Answer 5

Diferencia entre el operador lógico bit a- 1. El operador bit a bit trabaja en bit mientras que el operador lógico trabaja en la instrucción. 2. Bit a bit y se representa por & mientras que es lógico y está representado por & &. 3. Bit a bit o está representado por | mientras que es lógico o está representado por ||.