Booleanos en Java

boolean es el tipo primitivo más simple: tiene exactamente dos valores, true y false. Toda condición en Java — if, while, el operador ternario ?:, los operandos de && y || — requiere un boolean. No es necesario saber mucho sobre el tipo, pero conocer la diferencia entre boolean y Boolean evita futuros errores.

Esta página cubre la declaración de booleanos, dónde los requiere el compilador, los operadores lógicos, la clase envolvente Boolean y su trampa con null, el análisis de cadenas y cómo almacenar muchas banderas eficientemente.

Declarar un boolean

boolean isOpen = true;
boolean ready = false;
boolean canPay = (balance >= amount);

Las palabras clave son true y false — en minúsculas. No existe True, ni TRUE, ni 1, ni 0 — Java es estricto.

Un boolean que no se inicializa tiene un valor por defecto definido solo como campo (variable de instancia o estática), donde comienza en false. Una variable local no tiene valor por defecto — leerla antes de asignarla impide que el código compile:

class Light {
    boolean on;            // field — defaults to false

    void check() {
        boolean ready;     // local — no default
        // System.out.println(ready); // compile error: variable not initialized
        ready = true;
        System.out.println(ready); // OK now
    }
}

Booleanos en condiciones

Cada if, while, do-while y la cláusula central de un bucle for espera un boolean:

boolean isAdult = age >= 18;

if (isAdult) {
    System.out.println("Welcome!");
}

while (!stopRequested) {
    process();
}

No se puede usar un número donde se requiere un boolean:

int x = 5;
// if (x) { ... }   // compile error: int is not a boolean
if (x != 0) { ... } // OK

Eso es una característica, no un inconveniente — elimina toda una familia de errores de C.

Operaciones con booleanos

Los tres operadores lógicos (Operadores Lógicos):

boolean a = true && false;   // false
boolean b = true || false;   // true
boolean c = !true;           // false

&& y || hacen cortocircuito: en a && b, si a es false, b nunca se evalúa; en a || b, si a es true, b se omite. Esto permite proteger una comprobación, por ejemplo s != null && s.isEmpty(). Los operadores de bits & y | evalúan ambos lados — casi nunca es lo que se quiere con booleanos.

Expresiones idiomáticas comunes

No compares un boolean con true o false — úsalo directamente. La variable es la condición:

if (isOpen == true) { }   // redundant
if (isOpen) { }           // idiomatic

if (isOpen == false) { }  // redundant
if (!isOpen) { }          // idiomatic

Para cambiar el estado de una bandera, asigna su negación. Este es el patrón estándar de "alternancia":

boolean visible = true;
visible = !visible;   // now false
visible = !visible;   // back to true

Boolean — la clase envolvente

La clase envolvente Boolean permite colocar booleanos en colecciones y pasarlos como objetos:

List<Boolean> answers = new ArrayList<>();
answers.add(true);
answers.add(false);

Map<String, Boolean> flags = new HashMap<>();
flags.put("debug", true);

El autoboxing convierte entre boolean y Boolean automáticamente. Lo que hay que tener en cuenta: una referencia Boolean puede ser null, pero un boolean primitivo no puede.

Boolean maybe = null;
if (maybe) { ... }   // throws NullPointerException — autounbox on null

Usa Boolean.TRUE.equals(maybe) o una comprobación explícita de null si es posible que sea null.

Analizar booleanos

Boolean.parseBoolean(s) devuelve true si la cadena es "true" (sin distinción de mayúsculas/minúsculas), y false para todo lo demás — incluyendo errores tipográficos y valores inesperados:

Boolean.parseBoolean("true");      // true
Boolean.parseBoolean("TRUE");      // true
Boolean.parseBoolean("yes");       // false
Boolean.parseBoolean("1");         // false
Boolean.parseBoolean(null);        // false

Si necesitas una validación estricta de la entrada, escribe tu propia comprobación en lugar de confiar en la semántica "todo-lo-que-no-es-true-es-false" de este método.

boolean[] vs BitSet

Para unos pocos booleanos, un boolean[] es suficiente y se lee claramente:

boolean[] flags = new boolean[8];
flags[3] = true;

Para miles o millones de banderas, BitSet es más eficiente en memoria — empaqueta las banderas en enteros largos internamente:

import java.util.BitSet;

BitSet seen = new BitSet();
seen.set(42);
System.out.println(seen.get(42));   // true

Una demostración

Qué sigue

Caracteres en Java (char) — el primitivo de 16 bits que almacena una única unidad de código Unicode.

Práctica