Operadores Java

Operadores são os pequenos símbolos que permitem fazer algo com valores: somá-los, compará-los, combinar testes booleanos, definir bits, escolher entre duas expressões. Este capítulo é um roteiro de todas as categorias de operadores do Java — cada categoria tem seu próprio capítulo dedicado com mais detalhes.

As categorias

Os operadores do Java se dividem em sete grupos:

Há também instanceof (verificação de tipo) e new (criação de objetos), que se comportam como operadores, mas estão vinculados a recursos específicos da linguagem.

Aritmético

Os cinco operadores aritméticos fazem o que fazem em qualquer linguagem, com uma particularidade:

int sum     = 7 + 3;     // 10
int diff    = 7 - 3;     // 4
int product = 7 * 3;     // 21
int quotient = 7 / 3;    // 2  ← integer division truncates
int remainder = 7 % 3;   // 1

Para divisão com números reais, pelo menos um operando deve ser double (ou convertido para tal). Veja Java Arithmetic Operators para o tratamento completo.

Unário

int x = 5;
int neg = -x;       // -5
int inc = ++x;      // pre-increment: x becomes 6, inc is 6
int post = x++;     // post-increment: post is 6, then x becomes 7
boolean b = !true;  // false

++ e -- existem nas formas prefixada e pós-fixada. O prefixo altera a variável e depois retorna o novo valor; o pós-fixo retorna o valor antigo e depois altera a variável. Use-os apenas em sua própria linha quando possível — incorporados em expressões, são uma fonte frequente de bugs.

Atribuição

A atribuição básica é =. As formas compostas combinam uma operação com atribuição:

int total = 0;
total += 5;    // total = total + 5
total *= 2;    // total = total * 2
total -= 1;    // total = total - 1

As formas compostas também funcionam com operadores bit a bit (&= |= ^=) e com deslocamentos (<<= >>= >>>=). Uma atribuição composta também realiza uma conversão implícita de volta ao tipo da variável, então byte b = 10; b += 5; compila mesmo que b + 5 seja um int — um simples b = b + 5; não funcionaria. Veja Java Assignment Operators para mais detalhes.

Comparação

boolean a = (5 > 3);   // true
boolean b = (5 == 5);  // true
boolean c = (5 != 5);  // false

== funciona em primitivos e referências. Em referências, testa a identidade do objeto (mesmo objeto na memória), não a igualdade do conteúdo. Para comparar o conteúdo de objetos, use .equals():

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);        // false — different objects
System.out.println(s1.equals(s2));   // true  — same contents

Isso pega todo mundo de surpresa na primeira vez. O capítulo Java Comparison Operators explica o porquê.

Lógico

Os três operadores lógicos combinam booleanos:

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

&& e || fazem curto-circuito — param de avaliar assim que o resultado é conhecido. Isso é essencial quando um lado pode lançar uma exceção:

if (list != null && list.size() > 0) { /* ... */ }  // safe — short-circuit

Como && para no primeiro false, list.size() nunca é chamado quando list é null, então não há NullPointerException. O capítulo Java Logical Operators cobre o curto-circuito e as formas sem curto-circuito &/| em detalhes.

Bit a bit

Para manipular bits individuais:

int and    = 0b1100 & 0b1010;   // 0b1000 = 8
int or     = 0b1100 | 0b1010;   // 0b1110 = 14
int xor    = 0b1100 ^ 0b1010;   // 0b0110 = 6
int not    = ~0;                 // -1 — all bits flipped
int left   = 1 << 4;             // 16  — shift left
int right  = 16 >> 2;            // 4   — shift right (sign-preserving)
int uright = -1 >>> 28;          // 15  — unsigned shift right

A maioria do código Java cotidiano usa esses operadores apenas para flags, hashing e I/O de baixo nível. Java Bitwise Operators aprofunda o tema.

Ternário

O operador ternário escolhe entre duas expressões:

int x = 10;
String parity = (x % 2 == 0) ? "even" : "odd";   // "even"

Ele avalia para um valor, por isso é mais útil como o lado direito de uma atribuição ou dentro de uma expressão maior. Para decisões com múltiplas etapas, use um if/else real para maior legibilidade.

Precedência de operadores

Quando vários operadores aparecem em uma expressão, o Java os avalia em uma ordem fixa. As precedências mais importantes, da maior para a menor:

1. ++, --, unary -, !, ~
2. *, /, %
3. +, -
4. <<, >>, >>>
5. <, <=, >, >=, instanceof
6. ==, !=
7. & (bitwise AND)
8. ^ (bitwise XOR)
9. | (bitwise OR)
10. &&
11. ||
12. ? :
13. =, +=, -=, etc.

Na dúvida, adicione parênteses. Eles não têm custo em tempo de execução e deixam a intenção clara para o próximo leitor.

Uma demonstração

O que vem a seguir

Os capítulos por categoria que seguem aprofundam cada grupo de operadores. Java Arithmetic Operators é o próximo.

Prática