Uso del operador Not en condiciones If en Java

1. Introducción

En las declaraciones if-else de Java, podemos realizar una determinada acción cuando una expresión es verdadera y una alternativa cuando es falsa . En este tutorial, aprenderemos cómo invertir la lógica usando el operador not .

2. La declaración if-else

Comencemos con una simple declaración if-else :

boolean isValid = true; if (isValid) { System.out.println("Valid"); } else { System.out.println("Invalid"); }

¿Qué pasa si nuestro programa solo necesita manejar el caso negativo? ¿Cómo volveríamos a escribir el ejemplo anterior?

Una opción es simplemente eliminar el código en el bloque if :

boolean isValid = true; if (isValid) { } else { System.out.println("Invalid"); }

Sin embargo, un bloque if vacío parece que puede ser un código incompleto y parece una forma larga de manejar solo la condición negativa. En su lugar, podríamos intentar probar si nuestra expresión lógica se evalúa como falsa :

boolean isValid = true; if (isValid == false) { System.out.println("Invalid"); }

La versión anterior es relativamente fácil de leer, aunque podría ser más difícil de hacer si la expresión lógica fuera más compleja. Java tiene una alternativa para nosotros, sin embargo, en la forma del operador not :

boolean isValid = true; if (!isValid) { System.out.println("Invalid"); }

3. El no operador

El operador not es un operador lógico, representado en Java por el ! símbolo. Es un operador unario que toma un valor booleano como operando. El operador not funciona invirtiendo (o negando) el valor de su operando .

3.1. Aplicar el operador not a un valor booleano

Cuando se aplica a un valor booleano, el operador not cambia de verdadero a falso y de falso a verdadero .

Por ejemplo:

System.out.println(!true); // prints false System.out.println(!false); // prints true System.out.println(!!false); // prints false

3.2. Aplicar el operador not a una expresión booleana

Dado que no es un operador unitario, cuando se quiere no el resultado de una expresión, es necesario rodear esa expresión entre paréntesis para obtener la respuesta correcta. La expresión entre paréntesis se evalúa primero y luego el operador not invierte su resultado.

Por ejemplo:

int count = 2; System.out.println(!(count > 2)); // prints true System.out.println(!(count <= 2)); // prints false
boolean x = true; boolean y = false; System.out.println(!(x && y)); // prints true System.out.println(!(x || y)); // prints false 

Debemos tener en cuenta que al negar una expresión entran en juego las leyes de De Morgan. En otras palabras, se niega cada término de la expresión y se invierte el operador. Esto puede ayudarnos a simplificar expresiones más difíciles de leer.

Por ejemplo:

!(x && y) is same as !x || !y !(x || y) is same as !x && !y !(a <3 && b == 10) is same as a>= 3 || b != 10 

4. Algunas trampas comunes

El uso del operador not a veces puede comprometer la legibilidad de nuestro código. Los aspectos negativos pueden ser más difíciles de comprender que los positivos. Veamos algunos ejemplos.

4.1. Negativos dobles

Debido a que el operador no es un operador de negación, usarlo con variables o funciones que tienen un nombre negativo puede resultar en un código difícil de leer. Esto es similar a los lenguajes naturales, donde los dobles negativos a menudo se consideran difíciles de entender.

Por ejemplo:

if (product.isActive()) {...}

lee mejor que

if (!product.isNotActive()) {...}

Si bien es posible que nuestra API no proporcione un método isActive , podemos crear uno para facilitar la lectura.

4.2. Condiciones complejas

El operador not a veces puede hacer que una expresión ya compleja sea aún más difícil de leer y comprender. Cuando esto sucede, podemos simplificar el código invirtiendo la condición o extrayendo métodos. Veamos algunos ejemplos de condiciones complejas por el operador not y cómo podemos simplificarlas invirtiendo la condición:

if (!true) // Complex if (false) // Simplified if (!myDate.onOrAfter(anotherDate)) // Complex if (myDate.before(anotherDate)) // Simplified if (!(a >= b)) // Complex if (a = 10 || total >= 1000)) // Complex if (count < 10 && total < 1000) // Simplified

5. Conclusión

En este artículo, discutimos el operador not y cómo se puede usar con valores booleanos, expresiones y declaraciones if-else .

También analizamos algunos errores comunes, causados ​​por la escritura de expresiones en su inverso y cómo solucionarlos.

Como siempre, el código fuente de los ejemplos utilizados en este artículo está disponible en GitHub.