Java Academy · Aula

Aritmética de Inteiros e Estouro

Compreenda a divisão inteira, o resto, o comportamento de estouro e como detectá-lo.

Aritmética de Inteiros e Estouro é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Aritmética de inteiros e estouro

Os inteiros do Java têm tamanhos fixos. Quando um cálculo excede o valor máximo ou mínimo, ele dá a volta silenciosamente — nenhuma exceção é lançada. Entender isso evita erros sutis.

Intervalos de inteiros

Cada tipo inteiro tem um intervalo limitado determinado pela largura em bits:

byte: -128 a 127
short: -32,768 a 32,767
int: -2,147,483,648 a 2,147,483,647
long: -9.2 × 10^18 a 9.2 × 10^18

System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Long.MAX_VALUE);    // 9223372036854775807
System.out.println(Byte.MAX_VALUE);    // 127

Estouro: volta silenciosa ao início

Adicionar 1 a Integer.MAX_VALUE faz o valor voltar para Integer.MIN_VALUE. Essa é uma aritmética de complemento de dois — o Java não oferece nenhuma garantia nem lança uma exceção.

int max = Integer.MAX_VALUE;
System.out.println(max + 1); // -2147483648 (overflow!)

byte b = 127;
b++;  // wraps to -128
System.out.println(b); // -128

// Real bug: counting votes in a large election with int
int votes = Integer.MAX_VALUE;
votes += 100; // silently wrong
System.out.println(votes); // negative number!

Detecção de estouro com Math.addExact

O Java 8+ introduziu Math.addExact(), multiplyExact() e subtractExact(), que lançam ArithmeticException em caso de estouro em vez de voltar silenciosamente ao início.

try {
    int result = Math.addExact(Integer.MAX_VALUE, 1);
} catch (ArithmeticException e) {
    System.out.println("Overflow detected!"); // prints this
}

try {
    long safe = Math.multiplyExact(100_000L, 100_000L);
    System.out.println(safe); // 10000000000
} catch (ArithmeticException e) {
    System.out.println("Multiply overflow");
}

Divisão inteira e módulo

A divisão inteira trunca em direção a zero. O operador % fornece o resto com o sinal do dividendo. Fique atento à divisão por zero — ela lança ArithmeticException.

System.out.println(10 / 3);    // 3 (not 3.33)
System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1 (sign follows dividend)
System.out.println(-10 % -3);  // -1

try {
    int x = 5 / 0; // ArithmeticException: / by zero
} catch (ArithmeticException e) {
    System.out.println(e.getMessage()); // / by zero
}

// Float division by zero gives Infinity, not exception
System.out.println(5.0 / 0); // Infinity

Aritmética com long para números grandes

Use long quando os valores puderem exceder o intervalo de int. Sempre acrescente L aos literais desse tipo para evitar estouro antes da atribuição.

// Bug: multiplication done as int, then widened
long wrong = 1_000_000 * 1_000_000;   // overflows int!
System.out.println(wrong); // -727379968 (wrong!)

// Fix: one operand is long
long correct = 1_000_000L * 1_000_000L;
System.out.println(correct); // 1000000000000

// Or cast first
long alsOk = (long) 1_000_000 * 1_000_000;
System.out.println(alsOk); // 1000000000000

Operadores de deslocamento de bits

Os operadores de deslocamento de bits são formas rápidas de multiplicar ou dividir por potências de 2:

n << k — deslocamento à esquerda: multiplica por 2^k
n >> k — deslocamento à direita com sinal: divide por 2^k
n >>> k — deslocamento à direita sem sinal: preenche com zeros

int n = 8;
System.out.println(n << 1);  // 16 (8 * 2)
System.out.println(n << 2);  // 32 (8 * 4)
System.out.println(n >> 1);  // 4  (8 / 2)
System.out.println(n >> 2);  // 2  (8 / 4)

// Check if number is power of 2
boolean isPow2 = n > 0 && (n & (n - 1)) == 0;
System.out.println(isPow2); // true

AND, OR e XOR em nível binário

Os operadores em nível binário atuam sobre posições individuais e são usados em permissões, sinalizadores e protocolos de baixo nível.

int a = 0b1010; // 10
int b = 0b1100; // 12

System.out.println(Integer.toBinaryString(a & b)); // 1000 (AND = 8)
System.out.println(Integer.toBinaryString(a | b)); // 1110 (OR  = 14)
System.out.println(Integer.toBinaryString(a ^ b)); // 0110 (XOR = 6)
System.out.println(Integer.toBinaryString(~a));    // ...11110101 (NOT)

// Permission flags example
int READ  = 0b001;
int WRITE = 0b010;
int EXEC  = 0b100;
int perms = READ | WRITE; // user has read+write
System.out.println((perms & EXEC) != 0); // false — no exec

Sublinhados em literais numéricos

O Java 7+ permite sublinhados em literais numéricos para melhorar a legibilidade. O compilador os ignora.

int million = 1_000_000;
long creditCard = 4_111_1111_1111_1111L;
double pi = 3.141_592_653_589_793;
int hex = 0xFF_EC_D1_2E;
int binary = 0b0001_0101_0110;

System.out.println(million);   // 1000000
System.out.println(creditCard); // 4111111111111111

BigInteger para precisão arbitrária

Quando os valores excederem long, use BigInteger. Ele não sofre estouro, mas é mais lento que os tipos primitivos. Use-o para chaves criptográficas, fatoriais e números astronômicos.

import java.math.BigInteger;

BigInteger factorial100 = BigInteger.ONE;
for (int i = 2; i <= 100; i++) {
    factorial100 = factorial100.multiply(BigInteger.valueOf(i));
}
System.out.println(factorial100.toString().length() + " digits"); // 158 digits

BigInteger a = new BigInteger("999999999999999999999999999999");
BigInteger b = new BigInteger("1");
System.out.println(a.add(b)); // 1000000000000000000000000000000

Prático: contador seguro contra transbordamento

Um padrão para implementar um contador que lida com o transbordamento de forma segura usando Math.addExact e recorrendo a Long.MAX_VALUE.

class SafeCounter {
    private long count = 0;

    public void increment() {
        try {
            count = Math.addExact(count, 1L);
        } catch (ArithmeticException e) {
            count = Long.MAX_VALUE; // cap at max
        }
    }

    public long get() { return count; }
}

SafeCounter sc = new SafeCounter();
sc.increment();
sc.increment();
System.out.println(sc.get()); // 2

Verificação rápida

Qual é o valor da expressão a seguir?

long result = 1_000_000 * 1_000_000;
System.out.println(result);

Recapitulação: aritmética de inteiros e transbordamento

Principais conclusões:

O transbordamento de inteiros dá a volta silenciosamente — nenhuma exceção é lançada por padrão
Use Math.addExact/multiplyExact/subtractExact para detectar o transbordamento
A divisão de inteiros trunca em direção a zero; o sinal de % segue o do dividendo
Use literais long (sufixo L) quando os resultados intermediários puderem ultrapassar o limite de int
BigInteger lida com valores arbitrariamente grandes sem transbordamento
Os operadores de deslocamento de bits são alternativas rápidas à multiplicação/divisão por potências de 2

Perguntas Frequentes

A aula “Aritmética de Inteiros e Estouro” é grátis?

Sim — o texto completo de “Aritmética de Inteiros e Estouro” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Aritmética de Inteiros e Estouro”?

Compreenda a divisão inteira, o resto, o comportamento de estouro e como detectá-lo. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Aritmética de Inteiros e Estouro”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy