Operadores de Atribuição em Java

O = simples é o operador de atribuição básico. Java também fornece uma família de operadores de atribuição compostos que combinam uma operação aritmética, bit a bit ou de deslocamento com a própria atribuição. Eles economizam alguns caracteres e tornam a intenção — "modificar esta variável no lugar" — mais clara.

Atribuição simples

O lado direito é avaliado e então armazenado na variável do lado esquerdo:

int x = 5;
int y = x + 3;
y = y * 2;
System.out.println(y);   // 16

Algumas regras:

• O lado esquerdo deve ser uma variável (ou posição de array, ou campo), nunca uma expressão como (x + 1) = 5.
• Os tipos devem corresponder — ou o lado direito deve ser implicitamente conversível para o tipo do lado esquerdo.
• A atribuição é em si uma expressão: int a = (b = 5); define tanto a quanto b como 5.

Operadores de atribuição compostos

Cada operador aritmético e bit a bit possui uma forma de atribuição composta correspondente:

Na prática:

int total = 0;
total += 5;    // total = 5
total += 3;    // total = 8
total *= 2;    // total = 16
total -= 1;    // total = 15
total /= 3;    // total = 5

As formas bit a bit e de deslocamento funcionam da mesma maneira — aplicam a operação ao valor atual da variável e armazenam o resultado de volta:

int flags = 0b0101;   // 5
flags |= 0b0010;      // set a bit  -> 0b0111 = 7
flags &= 0b0110;      // clear bits -> 0b0110 = 6
flags <<= 1;          // shift left -> 0b1100 = 12

O lado direito é agrupado como um todo

x op= y não é uma substituição de texto simples de x = x op y. O compilador trata todo o lado direito como um único operando, como se estivesse entre parênteses — x = x op (y):

int x = 10;
x *= 2 + 3;   // x = x * (2 + 3) = 50, NOT x = x * 2 + 3 = 23
System.out.println(x);   // 50

+= com strings

+= também concatena em uma string:

String greeting = "Hello";
greeting += ", world!";   // "Hello, world!"

Cada += em uma String cria uma nova string internamente — strings são imutáveis. Para laços que constroem uma string longa, use StringBuilder (abordado em Concatenação de Strings em Java).

A atribuição composta inclui um cast implícito

Uma peculiaridade sutil, mas importante: os operadores de atribuição composta incluem um cast implícito de volta ao tipo da variável. A atribuição simples não faz isso.

byte b = 10;
// b = b + 1;       // compile error: int can't fit into byte without a cast
b += 1;             // OK — compound form casts implicitly
System.out.println(b);   // 11

Isso pode ser útil — e ocasionalmente um problema silencioso se ocultar um overflow.

A atribuição é uma expressão — mas não abuse dela

Como a atribuição produz um valor, você pode encadeá-la:

int a, b, c;
a = b = c = 10;     // all three set to 10

Você também pode atribuir dentro de um teste if:

String line;
while ((line = reader.readLine()) != null) {
    process(line);
}

Esses idiomas são comuns em laços de I/O. Fora de while ((x = ...) != null), prefira instruções separadas — são mais fáceis de ler.

= vs ==

A maior fonte de bugs de um único caractere em Java é confundir = (atribuição) e == (comparação):

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

Para int e a maioria dos tipos, o compilador detecta o erro imediatamente porque = retorna um int, não um boolean. Com variáveis boolean não há erro de compilação — a atribuição com = sempre retorna o boolean atribuído — então tome cuidado especial ao testar flags:

boolean isOpen = false;
if (isOpen = true) { ... }   // bug: this sets isOpen and is always true
if (isOpen == true) { ... }  // works, but...
if (isOpen) { ... }          // ...this is what you actually want

Uma demonstração

O que vem a seguir

Operadores de Comparação em Java aborda ==, !=, os operadores relacionais e a diferença crucial entre == e .equals() para objetos.

Prática