Operadores Aritméticos em Java

Java possui cinco operadores aritméticos: adição, subtração, multiplicação, divisão e resto. A sintaxe é a mesma que em C, JavaScript ou Python — mas a tipagem estática do Java introduz algumas surpresas relacionadas à divisão e ao overflow que vale conhecer antes de escrever qualquer cálculo.

Esta página cobre os cinco operadores, por que a divisão inteira trunca, como % se comporta com números negativos, precedência de operadores, os atalhos ++/--, overflow inteiro silencioso e a armadilha da precisão de ponto flutuante. Para o conjunto completo de operadores Java, consulte a visão geral de Operadores Java.

Os cinco operadores

int a = 14;
int b = 4;

System.out.println(a + b);  // 18
System.out.println(a - b);  // 10
System.out.println(a * b);  // 56
System.out.println(a / b);  // 3   — integer division
System.out.println(a % b);  // 2   — remainder

A divisão inteira trunca

Quando ambos os operandos de / são inteiros, o resultado é um inteiro e a parte fracionária é descartada (truncada em direção a zero):

System.out.println(7 / 2);    // 3, not 3.5
System.out.println(-7 / 2);   // -3
System.out.println(1 / 3);    // 0

Para obter um resultado com número real, pelo menos um operando deve ser do tipo ponto flutuante. Você pode escrever um literal como double (7.0) ou fazer um cast de int para double:

System.out.println(7.0 / 2);        // 3.5
System.out.println(7 / 2.0);        // 3.5
System.out.println((double) 7 / 2); // 3.5

O cast tem prioridade maior que /, então (double) 7 / 2 converte 7 primeiro e depois divide — resultando em 3.5. Cuidado com (double) (7 / 2): a divisão inteira acontece primeiro e você obtém 3.0.

Isso confunde iniciantes constantemente. Se você vir 0 onde esperava um quociente diferente de zero, suspeite de divisão inteira.

O operador de resto %

% retorna o resto da divisão inteira. É definido de forma que (a / b) * b + (a % b) == a:

System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1  — sign matches the dividend
System.out.println(10 % -3);   // 1

Usos comuns:

• Testar divisibilidade: if (n % 2 == 0) verifica se é par.
• Indexação circular: arr[(i + 1) % arr.length] volta ao 0 após o último elemento.
• Extrair dígitos ou unidades: n % 10 é o último dígito; seconds % 60 são os segundos no minuto.

Para mais funções numéricas — potências, arredondamento, raízes quadradas — consulte a Classe Math do Java.

% também funciona com double, retornando o resto IEEE 754 — útil, mas o método Math.IEEEremainder oferece controle mais preciso.

Precedência de operadores

As regras padrão se aplicam:

1. *, /, % primeiro
2. depois +, -
3. da esquerda para a direita dentro do mesmo nível de precedência

int result = 2 + 3 * 4;      // 14, not 20
int result2 = (2 + 3) * 4;   // 20
int result3 = 10 - 2 - 3;    // 5  — left-to-right

Na dúvida, use parênteses. Não custa nada.

Incremento e decremento — ++ e --

Os operadores unários ++ e -- incrementam ou decrementam uma variável em 1:

int x = 5;
x++;     // x is 6
x--;     // x is 5

Existem nas formas prefixada (++x) e pós-fixada (x++). A diferença só importa dentro de uma expressão:

int a = 5;
int b = a++;   // postfix: b is 5 (old value), a becomes 6
int c = ++a;   // prefix: a becomes 7, c is 7

Para facilitar a leitura, mantenha ++ e -- em sua própria linha sempre que possível.

O overflow ocorre silenciosamente

A aritmética inteira com int e long dá a volta no overflow — não lança exceção:

int max = Integer.MAX_VALUE;    // 2147483647
int wrapped = max + 1;          // -2147483648 (Integer.MIN_VALUE)

Se você precisar detectar overflow, use Math.addExact, Math.multiplyExact, etc., que lançam ArithmeticException em caso de overflow.

Peculiaridades do ponto flutuante

double segue o padrão IEEE 754 — rápido e bem suportado, mas não consegue representar a maioria das frações decimais com exatidão:

System.out.println(0.1 + 0.2);   // 0.30000000000000004

Isso não é um bug do Java — é como o ponto flutuante binário funciona. Para valores monetários, precisão científica ou qualquer situação que exija aritmética decimal exata, use BigDecimal:

import java.math.BigDecimal;

BigDecimal sum = new BigDecimal("0.1").add(new BigDecimal("0.2"));
System.out.println(sum);   // 0.3

(Sempre passe uma string para new BigDecimal(...); new BigDecimal(0.1) ainda capturaria a imprecisão binária.)

Uma demonstração

O que vem a seguir

Operadores de Atribuição em Java — =, += e a família de atribuições compostas.

Prática