Java Booleans

boolean ist der einfachste primitive Typ: Er hat genau zwei Werte, true und false. Jede Bedingung in Java — if, while, das ternäre ?:, die Operanden von && und || — erwartet einen boolean. Man muss nicht viel über diesen Typ wissen, aber den Unterschied zwischen boolean und Boolean zu kennen verhindert zukünftige Fehler.

Diese Seite behandelt die Deklaration von Booleans, wo der Compiler sie erfordert, die logischen Operatoren, die Wrapper-Klasse Boolean und ihre null-Falle, das Parsen von Strings sowie die effiziente Speicherung vieler Flags.

Einen boolean deklarieren

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

Die Schlüsselwörter sind true und false — in Kleinschreibung. Es gibt kein True, kein TRUE, keine 1, keine 0 — Java ist streng.

Ein nicht initialisierter boolean hat nur als Feld (Instanz- oder statische Variable) einen definierten Standardwert, der false ist. Eine lokale Variable hat keinen Standardwert — wird sie vor der Zuweisung gelesen, lässt sich der Code nicht kompilieren:

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

Booleans in Bedingungen

Jede if-, while-, do-while-Anweisung und die mittlere Klausel einer for-Schleife erwartet einen boolean:

boolean isAdult = age >= 18;

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

while (!stopRequested) {
    process();
}

Man kann keine Zahl verwenden, wo ein boolean erforderlich ist:

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

Das ist ein Feature, kein Nachteil — es eliminiert eine ganze Klasse von C-Fehlern.

Boolean-Operationen

Die drei logischen Operatoren (Logische Operatoren):

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

&& und || sind Kurzschluss-Operatoren: Bei a && b wird b nicht ausgewertet, wenn a false ist; bei a || b wird b übersprungen, wenn a true ist. So kann man einen Check absichern, z. B. s != null && s.isEmpty(). Die bitweisen Operatoren & und | werten beide Seiten aus — bei Booleans so gut wie nie das Gewünschte.

Gebräuchliche Idiome

Einen boolean nicht mit true oder false vergleichen — ihn direkt verwenden. Die Variable ist die Bedingung:

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

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

Um einen Flag umzuschalten, seine Negation zuweisen. Das ist das standardmäßige „Toggle"-Muster:

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

Boolean — die Wrapper-Klasse

Die Wrapper-Klasse Boolean ermöglicht es, Booleans in Collections zu speichern und als Objekte weiterzugeben:

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

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

Autoboxing konvertiert automatisch zwischen boolean und Boolean. Das Wichtigste, worauf man achten muss: Eine Boolean-Referenz kann null sein, ein primitiver boolean hingegen nicht.

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

Boolean.TRUE.equals(maybe) oder eine explizite Null-Prüfung verwenden, wenn null möglich ist.

Booleans parsen

Boolean.parseBoolean(s) gibt true zurück, wenn der String "true" ist (ohne Berücksichtigung der Groß-/Kleinschreibung), und false für alles andere — einschließlich Tippfehler und unerwarteter Werte:

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

Wenn eine strenge Eingabevalidierung benötigt wird, empfiehlt es sich, eine eigene Prüfung zu schreiben, anstatt sich auf die „alles-was-nicht-true-ist-ist-false"-Semantik dieser Methode zu verlassen.

boolean[] vs. BitSet

Für wenige Booleans ist ein boolean[] gut geeignet und gut lesbar:

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

Für Tausende oder Millionen von Flags ist BitSet speichereffizienter — es packt Flags intern in Longs:

import java.util.BitSet;

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

Eine Demonstration

Was kommt als Nächstes

Java-Zeichen (char) — der 16-Bit-Primitiv, der eine einzelne Unicode-Codeeinheit enthält.

Übungen