Les booléens en Java

boolean est le primitif le plus simple : il ne possède que deux valeurs, true et false. Chaque condition en Java — if, while, l'opérateur ternaire ?:, les opérandes de && et || — attend un boolean. Vous n'avez pas besoin de beaucoup en savoir sur ce type, mais connaître la différence entre boolean et Boolean vous évitera un futur bug.

Cette page aborde la déclaration des booléens, les endroits où le compilateur les exige, les opérateurs logiques, le wrapper Boolean et son piège null, l'analyse de chaînes, et la façon de stocker efficacement de nombreux indicateurs.

Déclarer un boolean

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

Les mots-clés sont true et false — en minuscules. Il n'existe pas de True, ni TRUE, ni 1, ni 0 — Java est strict.

Un boolean non initialisé n'a une valeur par défaut définie que s'il est un champ (variable d'instance ou statique), où il vaut false au départ. Une variable locale n'a pas de valeur par défaut — lisez-la avant de lui affecter une valeur et le code ne compilera pas :

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

Les booléens dans les conditions

Chaque instruction if, while, do-while, et la clause centrale d'une boucle for attend un boolean :

boolean isAdult = age >= 18;

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

while (!stopRequested) {
    process();
}

Vous ne pouvez pas utiliser un nombre là où un boolean est requis :

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

C'est une fonctionnalité, pas une contrainte — elle élimine toute une catégorie de bugs issus du C.

Opérations booléennes

Les trois opérateurs logiques (Opérateurs Logiques) :

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

&& et || effectuent un court-circuit : dans a && b, si a est false, b n'est jamais évalué ; dans a || b, si a est true, b est ignoré. Cela permet de protéger une vérification, par exemple s != null && s.isEmpty(). Les opérateurs bit à bit & et | évaluent les deux côtés — ce n'est presque jamais ce que vous souhaitez avec des booléens.

Idiomes courants

Ne comparez pas un boolean à true ou false — utilisez-le directement. La variable est la condition :

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

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

Pour inverser un indicateur, affectez sa négation. C'est le modèle standard de « bascule » :

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

Boolean — le wrapper

La classe wrapper Boolean vous permet de placer des booléens dans des collections et de les passer en tant qu'objets :

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

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

L'autoboxing convertit automatiquement entre boolean et Boolean. Le point à surveiller : une référence Boolean peut être null, mais un boolean primitif ne le peut pas.

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

Utilisez Boolean.TRUE.equals(maybe) ou une vérification explicite de null si null est possible.

Analyser des booléens

Boolean.parseBoolean(s) retourne true si la chaîne vaut "true" (insensible à la casse), et false pour tout le reste — y compris les fautes de frappe et les valeurs inattendues :

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

Si vous avez besoin d'une validation stricte des entrées, écrivez votre propre vérification plutôt que de vous fier à la sémantique « tout-ce-qui-n'est-pas-true-est-false » de cette méthode.

boolean[] vs BitSet

Pour quelques booléens, un boolean[] convient parfaitement et se lit clairement :

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

Pour des milliers ou des millions d'indicateurs, BitSet est plus efficace en mémoire — il compresse les indicateurs dans des longs en interne :

import java.util.BitSet;

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

Une démonstration

Et ensuite

Les caractères Java (char) — le primitif 16 bits qui contient une seule unité de code Unicode.

Pratique