Cortocircuito del operador lógico de Java

7 minutos de lectura

Cortocircuito del operador logico de Java
Aarón

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

}

  • Consulte esta pregunta: stackoverflow.com/questions/7101992/…

    – Ing. Fouad

    6 de enero de 2012 a las 15:07

  • El conjunto B no usa operadores lógicos. Estos utilizan los operadores bit a bit que comparan cada bit de los operandos.

    – Creador de nómadas

    1 de marzo de 2021 a las 18:50

Cortocircuito del operador logico de Java
bohemio

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

  • Me gustaría ampliar un poco esta respuesta. El operador &= es una forma abreviada de x = x & expresión y, por lo tanto, NO provoca un cortocircuito. Lo mismo ocurre con el operador |=.

    – Nube de tormenta

    4 sep 2015 a las 10:26

  • Una cosa que me gustaría destacar, | y & son operadores binarios, mientras que && y || son operadores condicionales (lógicos). | and & funciona en algo más que booleanos, mientras que && and || trabajar solo en booleanos.

    – Un mito

    30/10/2015 a las 18:05


  • No solo no evalúan la expresión del lado derecho, sino que el código no se ejecuta para que haya algo que evaluar. Este es un punto crítico de comprensión si de lo contrario se produciría un efecto secundario.

    – mckenzm

    5 de agosto de 2019 a las 4:28

  • @mckenzm ¿Cuál es la diferencia entre evaluado y ejecutado?

    – Kronen

    11 de mayo de 2020 a las 11:37

  • @Kronen La ejecución puede resultar en más que la evaluación y producir un efecto secundario, como una excepción o un retraso, pagaré no relevante para este ejemplo.

    – mckenzm

    11 mayo 2020 a las 20:37

1646975588 559 Cortocircuito del operador logico de Java
afrischke

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)

  • Por favor, especifique que este es el caso de &&, || funciona de manera diferente y dejará de evaluarse en el primer operando que devuelva verdadero;)

    – fge

    6 de enero de 2012 a las 15:12

  • De hecho, para ser realmente completo, todos &&, ||, & y | evaluar de izquierda a derecha. Para un conjunto de booleanos b1, b2, …, bn, las versiones de cortocircuito dejarán de evaluarse cuando el primero de estos booleanos sea verdadero (||) o falso (&&). Bah, el principio está ahí 😉

    – fge

    06/01/2012 a las 15:30

  • @fge: Sí, tienes razón, por supuesto. Tu definición es más exacta que la mía. He actualizado mi respuesta con la oración en tu comentario. Espero que no te moleste.

    – afrischke

    6 de enero de 2012 a las 15:39

  • No te preocupes, el conocimiento no tiene valor si no se comparte.

    – fge

    6 de enero de 2012 a las 15:50

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.

1646975588 988 Cortocircuito del operador logico de Java
Bhesh Gurung

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()) { }
}

1646975588 74 Cortocircuito del operador logico de Java
Serguéi Kalinichenko

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

1646975589 837 Cortocircuito del operador logico de Java
4444

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.

1646975589 323 Cortocircuito del operador logico de Java
dimansha malrindu

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.

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad