Java Booleans

boolean é o primitivo mais simples: possui exatamente dois valores, true e false. Todo condicional em Java — if, while, o ternário ?:, os operandos de && e || — exige um boolean. Não é necessário saber muito sobre o tipo, mas conhecer a diferença entre boolean e Boolean evita futuros bugs.

Esta página aborda a declaração de booleans, onde o compilador os exige, os operadores lógicos, o wrapper Boolean e sua armadilha com null, o parsing de strings e como armazenar muitos flags de forma eficiente.

Declarando um boolean

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

As palavras-chave são true e false — em minúsculas. Não existe True, TRUE, 1 ou 0 — Java é rigoroso.

Um boolean não inicializado tem um valor padrão definido apenas como campo (variável de instância ou estática), onde começa como false. Uma variável local não tem valor padrão — lê-la antes de atribuir um valor resultará em erro de compilação:

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 em condições

Todo if, while, do-while e a cláusula intermediária de um laço for espera um boolean:

boolean isAdult = age >= 18;

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

while (!stopRequested) {
    process();
}

Não é possível usar um número onde um boolean é exigido:

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

Isso é uma funcionalidade, não um inconveniente — elimina toda uma família de bugs do C.

Operações com boolean

Os três operadores lógicos (Operadores Lógicos):

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

&& e || fazem curto-circuito: em a && b, se a é false, b nunca é avaliado; em a || b, se a é true, b é ignorado. Isso permite proteger uma verificação, por exemplo, s != null && s.isEmpty(). Os operadores bit a bit & e | avaliam ambos os lados — quase nunca é o que se deseja com booleans.

Idiomas comuns

Não compare um boolean com true ou false — use-o diretamente. A variável é a condição:

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

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

Para inverter um flag, atribua sua negação. Este é o padrão padrão de "alternância":

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

Boolean — o wrapper

A classe wrapper Boolean permite colocar booleans em coleções e passá-los como objetos:

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

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

O autoboxing converte entre boolean e Boolean automaticamente. O único ponto de atenção: uma referência Boolean pode ser null, mas um boolean primitivo não pode.

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

Use Boolean.TRUE.equals(maybe) ou uma verificação explícita de null se null for possível.

Parsing de booleans

Boolean.parseBoolean(s) retorna true se a string for "true" (sem diferenciação de maiúsculas/minúsculas), e false para qualquer outra coisa — incluindo erros de digitação e valores inesperados:

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

Se precisar de validação estrita de entrada, escreva sua própria verificação em vez de confiar na semântica "tudo que não é true é false" deste método.

boolean[] vs BitSet

Para poucos booleans, um boolean[] é suficiente e de fácil leitura:

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

Para milhares ou milhões de flags, BitSet é mais eficiente em memória — internamente empacota os flags em longs:

import java.util.BitSet;

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

Uma demonstração

O que vem a seguir

Java Characters (char) — o primitivo de 16 bits que armazena uma única unidade de código Unicode.

Prática