tipo - operadores en programacion en java

Operador lógico de Java cortocircuitado

Question

¿Qué conjunto está cortocircuitando, 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);
}

Answer 1

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

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

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

• false && ... - no es necesario saber cuál es el lado derecho, el resultado debe ser false
• true || ... true || ... - no es necesario saber cuál es el lado derecho, el resultado debe ser true

Comparemos el comportamiento en un simple ejemplo:

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 que no está en cortocircuito y lanzará una NullPointerException si la input es null , pero la primera versión devolverá false sin excepción;

Answer 2

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

Eg Expression es: True || Falso

En el caso de ||, todo lo que necesitamos es uno de los lados para ser cierto. Entonces, si el lado izquierdo es verdadero, no tiene sentido revisar el lado derecho y, por lo tanto, eso no se verificará en absoluto.

Del mismo modo, False && True

En el caso de &&, necesitamos que ambos lados sean Verdaderos. Entonces, si el lado izquierdo es False, no tiene sentido marcar el lado derecho, la respuesta debe ser False. Y, por lo tanto, eso no se verificará en absoluto.

Answer 3

En términos simples, el cortocircuito significa detener la evaluación una vez que se sabe que la respuesta ya no puede cambiar. Por ejemplo, si está evaluando una cadena de AND lógicas y descubre un FALSE en el medio de esa cadena, sabrá que el resultado será falso, sin importar cuáles sean los valores del resto de las expresiones de la cadena . Lo mismo ocurre con una cadena de OR : una vez que descubre un TRUE , conoce la respuesta de inmediato, y así puede omitir la evaluación del resto de las expresiones.

Usted indica a Java que desea un cortocircuito utilizando && lugar de & y || en lugar de | . El primer conjunto de tu publicación está cortocircuitando.

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

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

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

Answer 4

Hay un par de diferencias entre los operadores & y && . Las mismas diferencias se aplican a | y || . Lo más importante a tener en cuenta es que && es un operador lógico que solo se aplica a operandos booleanos, mientras que & es un operador bit a bit que se aplica tanto a tipos enteros como a booleanos.

Con una operación lógica, puede hacer un cortocircuito porque en ciertos casos (como el primer operando de && es false o el primer operando de || es true ), no necesita evaluar el resto de la expresión. Esto es muy útil para hacer cosas como verificar null antes de acceder a un archivo o método, y verificar posibles ceros antes de dividir por ellos. Para una expresión compleja, cada parte de la expresión se evalúa recursivamente de la misma manera. Por ejemplo, en el siguiente caso:

(7 == 8) || ((1 == 3) && (4 == 4))

Solo las porciones enfatizadas serán evaluadas. Para calcular el || , primero compruebe si 7 == 8 es true . Si lo fuera, el lado derecho se saltaría por completo. El lado derecho solo verifica si 1 == 3 es false . Como lo es, 4 == 4 no necesita ser verificado, y toda la expresión se evalúa como false . Si el lado izquierdo fuera true , por ej. 7 == 7 lugar de 7 == 8 , todo el lado derecho se saltaría porque el todo || la expresión sería true independientemente

Con una operación en modo bit, necesita evaluar todos los operandos porque realmente solo está combinando los bits. Los booleanos son efectivamente un entero de un bit en Java (independientemente de cómo funcionen las funciones internas), y es solo una coincidencia que pueda hacer un cortocircuito para los operadores bit a bit en ese caso especial. La razón por la que no se puede cortocircuitar un entero general o | operación es que algunos bits pueden estar encendidos y algunos pueden estar desactivados en cualquiera de los operandos. Algo como 1 & 2 produce cero, pero no hay forma de saberlo sin evaluar ambos operandos.

Answer 5

Java proporciona dos operadores booleanos interesantes que no se encuentran en la mayoría de los otros lenguajes de programación. 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 resulta verdadero cuando A es verdadero, sin importar qué B sea.

De manera similar, el operador AND da como resultado falso cuando A es falso, sin importar qué B sea. Si usas el || y && formas, en lugar de | y & formas de estos operadores, Java no se molestará en evaluar solo el operando de la mano derecha. Esto es muy útil cuando el operando de la mano derecha depende de que el izquierdo 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 será válida antes de evaluarla:

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

Como se utiliza la forma de cortocircuito de AND ( && ), no hay riesgo de que una excepción en tiempo de ejecución se divida por cero. Si esta línea de código se escribiera usando la única & versión de AND, ambas partes tendrían que ser evaluadas, causando una excepción en tiempo de denom cuando el denom es cero.

Es una práctica estándar utilizar 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 único & asegura que la operación de incremento se aplicará a e si c es igual a 1 o no.

Answer 6

O lógico: devuelve verdadero si al menos uno de los operandos lo 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.

Answer 7

SET A utiliza los operadores booleanos en cortocircuito.

Lo que significa ''cortocircuito'' en el contexto de 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)

Answer 8

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

Este tipo provocará un cortocircuito, es decir, si (x < z) evalúa como falso, entonces el ú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 AND booleano que no produce cortocircuitos.

Puede probarlos de la siguiente manera (vea cuántas veces se llama el 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()) { }
}

Answer 9

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

Como se usa la forma de cortocircuito de AND (&&), no hay riesgo de causar una excepción en tiempo de ejecución cuando demonio es cero.

Árbitro. Java 2 Fifth Edition por Herbert Schildt