Cortocircuito del operador lógico de Java

¿Qué conjunto está en cortocircuito y qué significa exactamente que la expresión condicional compleja está en cortocircuito?

public static void main(String[] args) {
  int x, y, z;

  x = 10;
  y = 20;
  z = 30;

  // T T
  // T F
  // F T
  // F F

  //SET A
  boolean a = (x < z) && (x == x);
  boolean b = (x < z) && (x == z);
  boolean c = (x == z) && (x < z);
  boolean d = (x == z) && (x > z);
  //SET B    
  boolean aa = (x < z) & (x == x);
  boolean bb = (x < z) & (x == z);
  boolean cc = (x == z) & (x < z);
  boolean dd = (x == z) & (x > z);

}

los && y || los operadores “cortocircuitan”, lo que significa que no evalúan el lado derecho si no es necesario.

los & y | Los operadores, cuando se usan como operadores lógicos, siempre evalúan ambos lados.

Solo existe un caso de cortocircuito para cada operador, y son:

• false && ... – no es necesario saber cuál es el lado derecho porque el resultado sólo puede ser false independientemente del valor que haya
• true || ... – no es necesario saber cuál es el lado derecho porque el resultado sólo puede ser true independientemente del valor que haya

Comparemos el comportamiento en un ejemplo simple:

public boolean longerThan(String input, int length) {
    return input != null && input.length() > length;
}

public boolean longerThan(String input, int length) {
    return input != null & input.length() > length;
}

La segunda versión utiliza el operador sin cortocircuito. & y lanzará un NullPointerException si input es nullpero la primera versión volverá false sin excepción

SET A utiliza operadores booleanos de cortocircuito.

Lo que significa ‘cortocircuito’ en el contexto de los operadores booleanos es que para un conjunto de booleanos b1, b2, …, bn, las versiones de cortocircuito dejarán de evaluarse tan pronto como el primero de estos booleanos sea verdadero (|| ) o falso (&&).

Por ejemplo:

// 2 == 2 will never get evaluated because it is already clear from evaluating
// 1 != 1 that the result will be false.
(1 != 1) && (2 == 2)

// 2 != 2 will never get evaluated because it is already clear from evaluating
// 1 == 1 that the result will be true.
(1 == 1) || (2 != 2)

El cortocircuito significa que el segundo operador no será verificado si el primer operador decide el resultado final.

Por ejemplo, la expresión es: verdadero || Falso

En caso de ||, todo lo que necesitamos es uno del lado a decir verdad. Entonces, si el lado izquierdo es verdadero, no tiene sentido verificar el lado derecho y, por lo tanto, no se verificará en absoluto.

Del mismo modo, Falso && Verdadero

En caso de &&, necesitamos ambos lados a decir verdad. Entonces, si el lado izquierdo es Falso, no tiene sentido verificar el lado derecho, la respuesta tiene que ser Falso. Y por lo tanto, eso no se verificará en absoluto.

boolean a = (x < z) && (x == x);

Este tipo provocará un cortocircuito, lo que significa que si (x < z) se evalúa como falso, entonces este último no se evalúa, a será falso, de lo contrario && también evaluará (x == x).

& es un operador bit a bit, pero también un operador booleano AND que no provoca cortocircuitos.

Puede probarlos de la siguiente manera (vea cuántas veces se llama al método en cada caso):

public static boolean getFalse() {
    System.out.println("Method");
    return false;
}

public static void main(String[] args) {
    if(getFalse() && getFalse()) { }        
    System.out.println("=============================");        
    if(getFalse() & getFalse()) { }
}

En términos sencillos, cortocircuito significa detener la evaluación una vez que sepa que la respuesta ya no puede cambiar. Por ejemplo, si está evaluando una cadena de lógica ANDs y descubres un FALSE en medio de esa cadena, sabes que el resultado será falso, sin importar cuáles sean los valores del resto de las expresiones en la cadena. Lo mismo ocurre con una cadena de ORs: una vez que descubres un TRUEsabe la respuesta de inmediato, por lo que puede omitir la evaluación del resto de las expresiones.

Le indicas a Java que quieres hacer un cortocircuito usando && en lugar de & y || en lugar de |. El primer conjunto en su publicación es un cortocircuito.

Tenga en cuenta que esto es más que un intento de ahorrar algunos ciclos de CPU: en expresiones como esta

if (mystring != null && mystring.indexOf('+') > 0) {
    ...
}

un cortocircuito significa una diferencia entre el funcionamiento correcto y un bloqueo (en el caso de que mystring sea nulo).

Java proporciona dos operadores booleanos interesantes que no se encuentran en la mayoría de los demás lenguajes informáticos. Estas versiones secundarias de AND y OR se conocen como operadores lógicos de cortocircuito. Como puede ver en la tabla anterior, el operador OR da como resultado verdadero cuando A es verdadero, sin importar qué sea B.

De manera similar, el operador AND da como resultado falso cuando A es falso, sin importar qué sea B. Si usas el || y && formas, en lugar de | y & formas de estos operadores, Java no se molestará en evaluar solo el operando de la derecha. Esto es muy útil cuando el operando de la derecha depende de que el de la izquierda sea verdadero o falso para funcionar correctamente.

Por ejemplo, el siguiente fragmento de código muestra cómo puede aprovechar la evaluación lógica de cortocircuito para asegurarse de que una operación de división sea válida antes de evaluarla:

if ( denom != 0 && num / denom >10)

Dado que la forma de cortocircuito de AND (&&), no hay riesgo de causar una excepción en tiempo de ejecución al dividir por cero. Si esta línea de código se escribiera utilizando el único & versión de AND, ambos lados tendrían que ser evaluados, causando una excepción en tiempo de ejecución cuando denom es cero

Es una práctica estándar usar las formas de cortocircuito de AND y OR en casos que involucran lógica booleana, dejando las versiones de un solo carácter exclusivamente para operaciones bit a bit. Sin embargo, hay excepciones para esta regla. Por ejemplo, considere la siguiente declaración:

 if ( c==1 & e++ < 100 ) d = 100;

Aquí, usando un solo & asegura que la operación de incremento se aplicará a e ya sea c es igual a 1 o no.

OR lógico: devuelve verdadero si al menos uno de los operandos se evalúa como verdadero. Ambos operandos se evalúan antes de aplicar el operador OR.

Cortocircuito O: si el operando del lado izquierdo devuelve verdadero, devuelve verdadero sin evaluar el operando del lado derecho.