Java Booleans

boolean è il tipo primitivo più semplice: ha esattamente due valori, true e false. Ogni condizione in Java — if, while, l'operatore ternario ?:, gli operandi di && e || — richiede un boolean. Non occorre sapere molto su questo tipo, ma conoscere la differenza tra boolean e Boolean ti eviterà un bug futuro.

Questa pagina tratta la dichiarazione dei boolean, dove il compilatore li richiede, gli operatori logici, il wrapper Boolean e la sua trappola del null, il parsing di stringhe e come memorizzare molti flag in modo efficiente.

Dichiarare un boolean

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

Le parole chiave sono true e false — in minuscolo. Non esiste True, né TRUE, né 1, né 0 — Java è rigoroso.

Un boolean non inizializzato ha un valore predefinito definito solo come campo (variabile di istanza o statica), dove parte come false. Una variabile locale non ha valore predefinito — leggerla prima di assegnarla impedisce la compilazione del codice:

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
    }
}

I boolean nelle condizioni

Ogni if, while, do-while e la clausola centrale di un ciclo for si aspetta un boolean:

boolean isAdult = age >= 18;

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

while (!stopRequested) {
    process();
}

Non è possibile usare un numero dove è richiesto un boolean:

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

Questa è una caratteristica, non una limitazione — elimina un'intera categoria di bug tipici del C.

Operazioni sui boolean

I tre operatori logici (Operatori Logici):

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

&& e || sono in cortocircuito: in a && b, se a è false, b non viene mai valutato; in a || b, se a è true, b viene saltato. Questo ti permette di proteggere un controllo, ad es. s != null && s.isEmpty(). Gli operatori bitwise & e | valutano entrambi i lati — quasi mai quello che vuoi con i boolean.

Idiomi comuni

Non confrontare un boolean con true o false — usalo direttamente. La variabile è la condizione:

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

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

Per invertire un flag, assegna la sua negazione. Questo è il classico pattern "toggle":

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

Boolean — il wrapper

La classe wrapper Boolean ti permette di inserire boolean nelle collezioni e di passarli come oggetti:

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

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

L'autoboxing converte automaticamente tra boolean e Boolean. La cosa a cui fare attenzione: un riferimento Boolean può essere null, ma un primitivo boolean no.

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

Usa Boolean.TRUE.equals(maybe) o un controllo esplicito del null se il valore null è possibile.

Parsing dei boolean

Boolean.parseBoolean(s) restituisce true se la stringa è "true" (senza distinzione tra maiuscole e minuscole), e false per qualsiasi altro valore — incluse le varianti con errori di battitura e valori inattesi:

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

Se hai bisogno di una validazione rigorosa dell'input, scrivi il tuo controllo anziché affidarti alla semantica "tutto-ciò-che-non-è-true-è-false" di questo metodo.

boolean[] vs BitSet

Per pochi boolean, un boolean[] va bene ed è di chiara lettura:

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

Per migliaia o milioni di flag, BitSet è più efficiente in memoria — impacchetta i flag in long internamente:

import java.util.BitSet;

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

Una dimostrazione

Prossimi passi

Java Characters (char) — il primitivo a 16 bit che contiene una singola unità di codice Unicode.

Esercitati