Operadores de Comparação e Lógicos em Java

Operadores de Comparação e Lógicos são utilizados em expressões que avaliam condições e produzem resultados do tipo boolean, retornando true quando a condição é verdadeira e false caso contrário. São fundamentais para o controle de fluxo em instruções como if, while e outras estruturas condicionais.

Operadores de Comparação

Operadores de comparação realizam verificações entre dois operandos e retornam um valor boolean. O resultado é true se a comparação for verdadeira, e false caso contrário.

== (igualdade)
Compara dois valores. Retorna true se forem iguais, e false se forem diferentes:
```
int a = 10;
int b = 4;
boolean c = a == b;   // false
boolean d = a == 10;  // true
```
!= (diferença)
Retorna true se os valores forem diferentes, e false se forem iguais:
```
int a = 10;
int b = 4;
boolean c = a != b;   // true
boolean d = a != 10;  // false
```
< (menor que)
Retorna true se o primeiro operando for menor que o segundo:
```
int a = 10;
int b = 4;
boolean c = a < b;    // false
```
> (maior que)
Retorna true se o primeiro operando for maior que o segundo:
```
int a = 10;
int b = 4;
boolean c = a > b;    // true
```
>= (maior ou igual)
Retorna true se o primeiro valor for maior que ou igual ao segundo:
```
boolean c = 10 >= 10;   // true
boolean b = 10 >= 4;    // true
boolean d = 10 >= 20;   // false
```
<= (menor ou igual)
Retorna true se o primeiro valor for menor que ou igual ao segundo:
```
boolean c = 10 <= 10;   // true
boolean b = 10 <= 4;    // false
boolean d = 10 <= 20;   // true
```

Operadores Lógicos

Os operadores lógicos em Java também avaliam condições booleanas e retornam true ou false. São frequentemente usados para combinar expressões de comparação.

| (OU bit a bit)
Avalia ambos os operandos. Retorna true se pelo menos um deles for true; caso contrário, retorna false:
```
boolean c = a | b;
```
& (E bit a bit)
Avalia ambos os operandos. Retorna true apenas se ambos forem true; caso contrário, retorna false:
```
boolean c = a & b;
```
! (negação)
Inverte o valor booleano de um único operando. Se b for false, c será true; se b for true, c será false:
```
boolean c = !b;
```
^ (OU exclusivo)
Retorna true se apenas um dos operandos for true. Se ambos forem true ou ambos false, retorna false:
```
boolean c = a ^ b;
```
|| (OU lógico)
Avalia primeiro o operando à esquerda. Se for true, o operando à direita não é avaliado, pois o resultado já será true (avaliação de curto-circuito):
```
boolean c = a || b;
```
&& (E lógico)
Avalia primeiro o operando à esquerda. Se for false, o operando à direita não é avaliado, pois o resultado já será false (também com curto-circuito):
```
boolean c = a && b;
```

ℹ️ Os operadores &&, || e ! são exclusivos para lógica booleana e controle de fluxo. Na prática, são os mais utilizados, especialmente por oferecerem avaliação com curto-circuito (&& e ||) e negação (!), favorecendo tanto desempenho quanto legibilidade.
Já os operadores &, | e ^ podem ser usados com valores booleanos, mas também operam sobre inteiros. Com booleanos, sempre avaliam os dois lados da expressão. Com inteiros, realizam operações bit a bit, manipulando diretamente os bits binários dos operandos.
O operador ! atua somente sobre valores booleanos e não possui equivalente bit a bit.

Exemplos

boolean a1 = (5 > 6) || (4 < 6);  // false || true → true
boolean a2 = (5 > 6) || (4 > 6);  // false || false → false
boolean a3 = (5 > 6) && (4 < 6);  // false && (não avaliado) → false
boolean a4 = (50 > 6) && (4 / 2 < 3); // true && true → true
boolean a5 = (5 < 6) ^ (4 > 6);  // true ^ false → true
boolean a6 = (50 > 6) ^ (4 / 2 < 3); // true ^ true → false

📝 Exercícios

Tarefa 1: Qual é o resultado do operador OR?

O que o código abaixo vai exibir?

System.out.println( false || true || false );

Resposta

O operador || retorna true se pelo menos uma das expressões for verdadeira. Como a segunda é true, o resultado é true.

true

Tarefa 2: Qual é o resultado do operador AND?

System.out.println( true && false && true );

Resposta

O operador && só retorna true se todas as expressões forem verdadeiras. Como a segunda é false, o resultado da expressão completa é false.

false

Tarefa 3: Qual será o resultado da expressão combinando OR e AND?

System.out.println( false || true && true || false );

Resposta

Em Java, o operador && tem precedência maior que ||, então true && true é avaliado primeiro (resultado true). A expressão vira false || true || false, que resulta em true.

true

Tarefa 4: Qual dessas instruções será executada?

if (-1 != 0 || 0 != 0) System.out.println("primeiro");
if (-1 != 0 && 0 != 0) System.out.println("segundo");
if (false || (-1 != 0 && 1 != 0)) System.out.println("terceiro");

Resposta

Saída esperada:

primeiro
terceiro

Explicação:

-1 != 0 || 0 != 0 → true || false → true, imprime "primeiro"

-1 != 0 && 0 != 0 → true && false → false, não imprime

false || (true && true) → false || true → true, imprime "terceiro"