Java Operadores de Comparação

Programas tomam decisões o tempo todo: "a nota é suficiente para passar?", "o estoque acabou?", "a senha está certa?". Cada uma dessas perguntas é uma comparação, e a resposta é sempre sim ou não: true ou false. Nesta aula você vai conhecer os seis operadores de comparação do Java e as armadilhas de comparar textos e números decimais.

Os seis operadores

São os sinais da matemática da escola, escritos com os caracteres do teclado. A Ana tirou 7 na prova:

public class Main {
    public static void main(String[] args) {
        int nota = 7;
        System.out.println(nota == 7);
        System.out.println(nota != 7);
        System.out.println(nota > 6);
        System.out.println(nota < 6);
        System.out.println(nota >= 7);
        System.out.println(nota <= 5);
    }
}

$ javac Main.java && java Main
true               « 7 é igual a 7
false              « 7 é diferente de 7? não
true
false
true               « 7 é maior OU igual a 7
false

Detalhes de escrita que causam erro (todos com a mensagem real em Quando dá errado):

• Igualdade usa dois sinais: ==. Um só (=) é atribuição, assunto de Operadores de Atribuição.
• Os sinais de dois caracteres são escritos juntos e na ordem certa: >= e <= (nunca =>, =< ou = =). Dica: leia em voz alta, "maior ou igual": o > vem primeiro.
• != vem do !, que em Java quer dizer "não": "não igual".

O resultado é um boolean

Uma comparação não é uma ordem, é uma pergunta, e a resposta é um valor do tipo boolean (char e boolean). Como qualquer valor, ele pode ser guardado numa variável, impresso ou usado em outra conta:

public class Main {
    public static void main(String[] args) {
        int idade = 17;
        double altura = 1.65;
        boolean maiorDeIdade = idade >= 18;
        boolean podeBrincar = altura >= 1.40;
        System.out.println("Maior de idade? " + maiorDeIdade);
        System.out.println("Pode ir no brinquedo? " + podeBrincar);
        System.out.println(5 == 5.0);
        System.out.println('a' < 'b');
        System.out.println('Z' < 'a');
        System.out.println('A' == 65);
        System.out.println(true == false);
        System.out.println("Resultado: " + (3 > 2));
    }
}

$ javac Main.java && java Main
Maior de idade? false
Pode ir no brinquedo? true
true               « 5 == 5.0: o int vira double e os valores são iguais
true               « 'a' (97) < 'b' (98)
true               « 'Z' (90) < 'a' (97): maiúsculas vêm antes!
true               « 'A' é o código 65
false
Resultado: true

boolean

O tipo da variável: guarda true ou false.

maiorDeIdade

Um nome que soa como pergunta.

=

Atribuição: guarda o resultado da direita.

idade >= 18

A comparação, calculada primeiro: 17 >= 18 é false.

Na última linha, os parênteses em (3 > 2) são necessários: sem eles, o Java tentaria colar "Resultado: " + 3 antes de comparar, e o código não compilaria (veja Precedência).

O que dá para comparar

public class Main {
    public static void main(String[] args) {
        int idade = 16;
        boolean podeVotar = idade > 16;
        System.out.println("Pode votar? " + podeVotar);
    }
}

public class Main {
    public static void main(String[] args) {
        int idade = 16;
        boolean podeVotar = idade >= 16;
        System.out.println("Pode votar? " + podeVotar);
    }
}

A armadilha: == com String

Com tipos primitivos, == compara valores. Com objetos, como String, == compara outra coisa: se as duas variáveis apontam para o mesmo objeto na memória. Dois textos iguais podem estar em objetos diferentes:

public class Main {
    public static void main(String[] args) {
        String a = "Ana";
        String b = "Ana";
        String c = new String("Ana");
        System.out.println(a == b);
        System.out.println(a == c);
        System.out.println(a.equals(c));
    }
}

$ javac Main.java && java Main
true               « a e b: por acaso, o mesmo objeto
false              « a e c: mesmo texto, objetos diferentes!
true               « equals compara o TEXTO

O resultado de == depende de como a String foi criada, e textos digitados pelo usuário ou lidos de arquivos quase sempre são objetos novos. Por isso a regra é simples: para comparar textos, use equals: nome.equals("Ana"). A explicação completa, com a "prova real" e o equalsIgnoreCase, está em Strings. E < e > nem compilam com String; para ordem alfabética, existe compareTo, também em Strings.

Comparar double

Como você viu em double e float, contas com decimais acumulam pequenos erros. Uma comparação com == pode falhar mesmo quando "deveria" dar certo:

public class Main {
    public static void main(String[] args) {
        double total = 0.1 + 0.2;
        System.out.println(total == 0.3);
        System.out.println(Math.abs(total - 0.3) < 1e-9);
        double nada = 0.0 / 0;
        System.out.println(nada == nada);
        System.out.println(nada != nada);
        System.out.println(Double.isNaN(nada));
        System.out.println(0.1 + 0.2 > 0.3);
    }
}

$ javac Main.java && java Main
false              « 0.30000000000000004 não é 0.3
true               « com tolerância: "a diferença é menor que 0,000000001?"
false              « NaN não é igual nem a si mesmo
true
true
true               « 0.1 + 0.2 é (um pouquinho) MAIOR que 0.3

1e-9 é notação científica: 1 × 10^-9, ou 0,000000001.

0.1 + 0.2 == 0.3

Quando dá errado

public class Main {
    public static void main(String[] args) {
        int idade = 25;
        System.out.println(18 <= idade < 60);
    }
}

$ javac Main.java
Main.java:4: error: bad operand types for binary operator '<'
        System.out.println(18 <= idade < 60);
                                       ^
  first type:  boolean
  second type: int
1 error

public class Main {
    public static void main(String[] args) {
        int idade = 25;
        boolean pagaInteira = 18 <= idade < 60;
        System.out.println("Paga meia? " + !pagaInteira);
    }
}

public class Main {
    public static void main(String[] args) {
        int idade = 25;
        boolean pagaInteira = idade >= 18 && idade < 60;
        System.out.println("Paga meia? " + !pagaInteira);
    }
}

$ javac Main.java
Main.java:4: error: bad operand types for binary operator '=='
        System.out.println(letra == "a");
                                 ^
  first type:  char
  second type: String
1 error

$ javac Main.java
Main.java:4: error: illegal start of expression
        System.out.println(x => 3);
                              ^
1 error

$ javac Main.java
Main.java:4: error: illegal start of type
        System.out.println(x =< 3);
                                ^
1 error

Referência

Exercícios

Resumo

• Seis operadores: ==, !=, >, <, >=, <=. Igualdade tem dois sinais; os compostos têm o = por último.
• Toda comparação dá um boolean, que pode ser guardado: boolean aprovado = nota >= 6;.
• Números se comparam entre si (5 == 5.0 é true); char compara códigos Unicode; boolean só com == e !=.
• String: use equals, não ==.
• double: compare com tolerância; NaN se testa com Double.isNaN.
• "Entre dois valores" são duas comparações: x >= 18 && x < 60.