Valor Máximo de long em Java: Long.MAX_VALUE, Intervalo e Overflow (Com Exemplos)

1. Qual é o Valor Máximo do Tipo long do Java?

O valor máximo do tipo long do Java é 9223372036854775807.
Ele é definido como a constante Long.MAX_VALUE.

Primeiro, vamos confirmar a conclusão.

public class Main {
    public static void main(String[] args) {
        System.out.println(Long.MAX_VALUE);
    }
}

Saída:

9223372036854775807

Em outras palavras, este é o maior valor positivo que você pode armazenar em um long do Java.

1.1 O Valor Máximo do long É “9223372036854775807”

Este valor pode ser expresso pela seguinte fórmula:

2^63 - 1

O ponto chave é por que é “63”.

• O tipo long é um inteiro de 64 bits .
• 1 bit é usado para o sinal (positivo/negativo) .
• Os 63 bits restantes representam o valor numérico.

Portanto,

maximum value = 2^63 - 1

torna-se o máximo.

*Um “bit” é a menor unidade de dados que representa 0 ou 1.

1.2 Por Que Não É 2^64 − 1 Mesmo Sendo de 64 Bits?

Este é o ponto que mais confunde os iniciantes.

O long do Java é um inteiro com sinal.
“Com sinal” significa que ele pode representar valores positivos e negativos.

Quebra de 64 bits:

• 1 bit → sinal
• 63 bits → valor

Então o maior valor positivo é:

2^63 - 1

É por isso.

“2^64 – 1” aplica-se a um inteiro sem sinal.
O Java não tem um tipo unsigned long.

⚠ Mal-entendido comum

• × O valor máximo do long é 18446744073709551615
• ○ Correto: 9223372036854775807

1.3 Verifique Também o Valor Mínimo do long

O valor mínimo é outro item essencial para memorizar junto com o máximo.

System.out.println(Long.MIN_VALUE);

Saída:

-9223372036854775808

Na forma de fórmula:

-2^63

O valor absoluto é 1 maior que o máximo porque o Java gerencia inteiros usando complemento de dois.

*O complemento de dois é o mecanismo padrão que os computadores usam para representar números negativos.

Armadilhas Comuns e Notas

• Confundi-lo com 2^64-1
• Assumir que um unsigned long existe
• Tentar memorizar o valor diretamente e errar os dígitos
• Confundi-lo com int (32 bits)

Em particular, confundi-lo com o valor máximo do int (2147483647) é extremamente comum.

2. Como Obter o Valor Máximo de long no Java

Ao lidar com o valor máximo de long, a regra é: não escreva o número diretamente—use a constante.
Aqui explicaremos maneiras seguras e práticas de obtê-lo.

2.1 Use Long.MAX_VALUE (Recomendado)

No Java, o valor máximo é definido na classe java.lang.Long.

long max = Long.MAX_VALUE;
System.out.println(max);

Saída:

9223372036854775807

Por Que Você Deve Usar uma Constante?

• Previne erros de dígitos/erros de digitação
• Melhora a legibilidade
• Torna o tipo explícito
• Mais robusto para mudanças futuras (mudanças na especificação são improváveis, mas é mais seguro)

Nenhuma importação especial é necessária.
O pacote java.lang é importado automaticamente.

2.2 Notas Ao Escrever o Número Diretamente

Você também pode escrever o valor máximo diretamente.

long max = 9223372036854775807L;

A parte importante aqui é o “L” final.

Por Que o “L” É Necessário?

No Java, um literal inteiro (um literal numérico) é tratado como um int por padrão se nada for anexado.

Isso significa:

long max = 9223372036854775807;  // Error

Isso causa um erro de tempo de compilação.

Razão:

• Excede o intervalo do int
• Não indica explicitamente que é um long

Correto:

long max = 9223372036854775807L;

⚠ Um l minúsculo é difícil de distinguir do dígito 1, então L maiúsculo é recomendado.

2.3 Riscos de Hardcoding

“Hardcoding” significa escrever o valor numérico diretamente.

Exemplo:

if (value == 9223372036854775807L) {
    // Processing
}

Problemas:

• O significado não é claro
• Baixa manutenibilidade
• Difícil para outros desenvolvedores entenderem

Recomendado:

if (value == Long.MAX_VALUE) {
    // Processing
}

Isso deixa a intenção do código clara.

Erros Comuns

• Esquecer de adicionar L e obter um erro de compilação
• Tentar atribuí‑lo a uma variável int
• Escrever Long max = Long.MAX_VALUE; e não considerar o possível tratamento de null (ao usar classes wrapper)
• Tentar calculá‑lo com Math.pow(2,63) (torna‑se double e introduz problemas de precisão)

*Math.pow() retorna um double, portanto não é adequado para cálculos inteiros exatos.

3. O Que Acontece Se um long Exceder o Valor Máximo? (Overflow)

O tipo long só pode lidar com um intervalo finito.
Então, se você exceder o valor máximo, ele não lança um erro—seu valor volta ao início (cicla).
Isso é chamado de “overflow”.

3.1 Um Exemplo Real de Overflow

Vamos verificar na prática.

public class Main {
    public static void main(String[] args) {
        long max = Long.MAX_VALUE;
        long overflow = max + 1;

        System.out.println("Max value: " + max);
        System.out.println("Max value + 1: " + overflow);
    }
}

Saída:

Max value: 9223372036854775807
Max value + 1: -9223372036854775808

Você pode ver que max + 1 torna‑se o valor mínimo.

Isso não é anormal—é o comportamento definido pela especificação Java.

3.2 Por Que Não Se Torna um Erro?

Os tipos inteiros do Java (int / long) não lançam exceções quando o valor excede o intervalo.

Razão:

• Número fixo de bits (long tem 64 bits)
• Os valores circulam devido à representação em complemento de dois

Conceitualmente:

Max value → +1 → Min value
Min value → -1 → Max value

O computador simplesmente calcula bits, portanto não tem o conceito de “fora do intervalo”.

⚠ Confusão comum de iniciantes

• Assumindo que “será um erro”
• O sinal de repente inverte e se torna um bug

3.3 Como Detectar Overflow

Você não pode detectá‑lo com adição normal.

Método 1: Use Math.addExact() (Recomendado)

try {
    long result = Math.addExact(Long.MAX_VALUE, 1);
} catch (ArithmeticException e) {
    System.out.println("Overflow occurred");
}

Math.addExact() lança uma ArithmeticException quando o resultado excede o intervalo.

Existem também:

• Math.subtractExact()
• Math.multiplyExact()

também.

3.4 Como Fazer uma Verificação de Intervalo

Você também pode verificar antes de somar.

if (value > Long.MAX_VALUE - addValue) {
    System.out.println("Adding will overflow");
}

*Na prática, addExact() costuma ser mais seguro que esta abordagem.

3.5 Use BigInteger (Sem Limite Superior)

Se long não for suficiente, use BigInteger.

import java.math.BigInteger;

BigInteger a = new BigInteger("9223372036854775807");
BigInteger b = BigInteger.ONE;
BigInteger result = a.add(b);

System.out.println(result);

BigInteger não tem limite de dígitos.

Mas observe:

• Mais lento que long
• Usa mais memória
• Não é um tipo primitivo (é um tipo objeto)

Erros Comuns e Observações

• Usar long para cálculos monetários e não perceber overflow
• Gerar IDs sem considerar limites superiores
• Usar Math.pow e introduzir erros de precisão
• Converter para double e voltar (perda de precisão)

Isso pode se tornar um bug fatal, especialmente em processamento financeiro.

4. Comparando Valores Máximos com Outros Tipos Inteiros

Para entender corretamente o valor máximo de long, você também deve organizar como ele difere dos outros tipos inteiros.
No Java, cada tipo inteiro tem um intervalo claramente definido com base na sua largura de bits.

4.1 Diferença em relação ao int

int é um inteiro assinado de 32 bits.

System.out.println(Integer.MAX_VALUE);

Saída:

2147483647

Comparação:

Um long pode lidar com um intervalo cerca de 4,3 bilhões de vezes maior que um int.

⚠ Erros comuns

• Assumir que int é suficiente e depois causar overflow devido ao crescimento
• Mapear um BIGINT de banco de dados para int

4.2 Comparação com short e byte

Let’s also check smaller integer types.

System.out.println(Short.MAX_VALUE);  // 32767
System.out.println(Byte.MAX_VALUE);   // 127

Typical use cases:

• byte → casos de uso de compressão de dados
• short → valores numéricos de pequena escala
• int → processamento típico de inteiros
• long → IDs grandes e timestamps

4.3 When Should You Use long?

Typical cases where you use long:

• timestamps UNIX (milissegundos)
• colunas BIGINT de banco de dados
• IDs sequenciais grandes
• tamanhos de arquivos (bytes)

Example:

long timestamp = System.currentTimeMillis();

System.currentTimeMillis() returns a long.
This is because millisecond-level values do not fit in an int.

4.4 Risks of Using long Unnecessarily

A long uses 8 bytes.
An int uses 4 bytes.

When handling large amounts of data:

• O uso de memória aumenta
• A eficiência do cache diminui
• Impacto de desempenho (depende do ambiente)

Therefore,

If the range clearly fits in int, use int.

is the basic principle.

Common Mistakes and Notes

• O banco de dados é BIGINT mas Java usa int
• Receber valores numéricos JSON como int mesmo que assumam long
• Perda de precisão devido a casts implícitos durante a conversão de tipo
• Atribuir resultados de Math.pow diretamente a long

Bugs due to type mismatches are especially common in API integrations.

5. Practical Scenarios for Handling the Maximum long Value

The maximum value of long is not just theoretical knowledge—it is important in real-world development. Understanding it is essential, especially in processes where numeric overflow can become fatal.

5.1 UNIX Timestamps

When retrieving the current time in Java:

long now = System.currentTimeMillis();
System.out.println(now);

System.currentTimeMillis() returns the number of milliseconds since January 1, 1970.

If you store it in an int:

int now = (int) System.currentTimeMillis();  // Dangerous

The value is corrupted (only the lower 32 bits are kept).

⚠ Notes

• Truncamento devido a casting
• O problema do Ano 2038 (limite de timestamps baseados em int)
• Confundir segundos com milissegundos

Using long avoids the Year 2038 problem.

5.2 Integration with Databases (BIGINT)

In many databases, BIGINT is a 64-bit integer.

Example:

CREATE TABLE users (
    id BIGINT PRIMARY KEY
);

On the Java side:

long id;

If you receive it as an int:

• Corrupção de dados
• Exceções ao alcançar o limite superior
• Falta de escalabilidade futura

⚠ Common real-world mistakes

• int é suficiente no início → dígitos insuficientes depois
• Mapeamento de tipo incorreto no ORM
• Problemas de precisão numérica durante conversão JSON (JavaScript é seguro apenas até 53 bits)

5.3 ID Generation and Upper Limits

Distributed IDs (e.g., Snowflake-style IDs) typically use long.

Example:

long id = generateId();

Reasons:

• Espaço de 64 bits é suficientemente grande
• Sequência, timestamp e ID da máquina podem ser divididos em bits

However, theoretically, long also has an upper limit.

Example check:

if (currentId == Long.MAX_VALUE) {
    throw new IllegalStateException("ID upper limit reached");
}

In practice, this is rarely reached, but it should be considered in system design.

5.4 File Size Calculations

Getting a file size:

File file = new File("example.txt");
long size = file.length();

For large files, int is not sufficient.

⚠ Notes

• Não converta long para int
• Índices de array são int (é aqui que as limitações ocorrem)

Common Real-World Mistakes

• Perda de precisão no JavaScript ao lidar com long em JSON
• Não atualizar o código Java ao mudar tipos de colunas no DB
• Usar long para cálculos monetários e causar overflow
• Projetar IDs persistentes sem considerar limites superiores

6. Common Misconceptions About the long Maximum Value

O valor máximo de long é um tópico com muitos mal-entendidos nos resultados de busca.
Aqui organizamos os pontos mais confusos.

6.1 Não Existe long sem sinal em Java

Isso é especialmente confuso para desenvolvedores com experiência em C/C++.

Java não possui:

an unsigned long type

Um long é sempre um inteiro assinado de 64 bits.

Portanto, o valor positivo máximo é:

2^63 - 1

Esse é o limite.

Desde o Java 8, os seguintes métodos foram adicionados:

Long.compareUnsigned(a, b);
Long.divideUnsigned(a, b);

No entanto, esses são métodos auxiliares para operações sem sinal—ainda não existe um tipo long sem sinal.

6.2 O Valor Máximo Não É 2^64 − 1

Desinformação frequentemente encontrada online:

18446744073709551615

Este é o valor máximo de um inteiro sem sinal de 64 bits.

Como o long do Java é assinado:

The maximum value is 9223372036854775807

Esse é o valor correto.

Resumo da diferença:

Java usa o primeiro.

6.3 BigInteger e long São Diferentes

BigInteger representa inteiros com praticamente nenhum limite superior.

Diferença:

BigInteger:

• Usa mais memória
• Cálculos mais lentos
• Requer equals() para comparação

long:

• Rápido
• Leve
• Faixa fixa

Escolha de acordo com seu caso de uso.

6.4 É Perigoso Calcular o Máximo com Math.pow

Exemplo incorreto:

long max = (long) Math.pow(2, 63) - 1;

Problemas:

• Math.pow retorna um double
• double tem precisão de 53 bits
• Erros de precisão ocorrem para inteiros grandes

Abordagem correta:

long max = Long.MAX_VALUE;

Resumo das Confusões Comuns

• Pensar que long sem sinal existe
• Confundir com 2^64 – 1
• Tentar calculá-lo com Math.pow
• Perder precisão via conversão para double
• Confundir BigInteger com long

7. Resumo (Revisão Rápida)

Aqui está um resumo conciso dos pontos chave que você precisa na prática.

7.1 Resposta Final: Valor Máximo de long

• Valor máximo: 9223372036854775807
• Constante: Long.MAX_VALUE
• Fórmula: 2^63 – 1
• Tipo: inteiro assinado de 64 bits

Código de verificação:

System.out.println(Long.MAX_VALUE);

7.2 Regras Essenciais que Você Deve Seguir

• Não codifique o valor máximo numericamente—use Long.MAX_VALUE
• Adicione L ao escrever um literal long
• Não o confunda com int
• Overflow não lança uma exceção automaticamente

7.3 Como Prevenir Overflow

Para somar com segurança:

Math.addExact(a, b);

Se o valor puder exceder o limite:

• Use BigInteger
• Implemente verificações de faixa

7.4 Pontos Importantes na Prática

• Receba valores BIGINT do DB como long
• Use long para timestamps UNIX
• Tenha cuidado com a precisão em integrações JSON
• Considere limites superiores ao projetar sistemas de IDs

7.5 Checklist Mais Importante

• Você está usando erroneamente 2^64 – 1?
• Você assume que long sem sinal existe?
• Você está calculando isso com Math.pow?
• Você está convertendo long para int?
• Você entende o que acontece em caso de overflow?

O valor máximo de long não é apenas algo para memorizar—é um conceito central que afeta sua compreensão dos tipos inteiros como um todo.

Perguntas Frequentes

Q1. Qual é o valor máximo do long do Java?

9223372036854775807.
Você pode obtê-lo com Long.MAX_VALUE.

Q2. Quantos bits tem um long?

É um inteiro assinado de 64 bits.
1 bit é para o sinal, e os 63 bits restantes representam o valor.

Q3. O que acontece se você exceder Long.MAX_VALUE?

Nenhum erro ocorre.
Ele volta ao valor mínimo (-9223372036854775808).

System.out.println(Long.MAX_VALUE + 1);

Q4. O Java tem long sem sinal?

Não, não como um tipo.
Java 8 e posteriores fornecem métodos auxiliares para operações sem sinal, mas o tipo em si é sempre assinado.

Q5. Existe uma maneira segura de calcular o valor máximo?

Não calcule-o diretamente. Sempre use:

Long.MAX_VALUE

Math.pow() retorna um double e, portanto, é impreciso para inteiros grandes.

Q6. Devo usar int ou long?

• Se o intervalo está dentro de aproximadamente 2,1 bilhões → use int
• Se pode exceder isso → use long

Use long para colunas DB BIGINT e timestamps.

Q7. Quantos dígitos o long pode suportar?

O valor máximo tem 19 dígitos:
9223372036854775807

Q8. Qual é a diferença entre long e BigInteger?

• long → 64 bits fixos, rápido
• BigInteger → praticamente ilimitado, mais lento

Se o intervalo cabe dentro do long, usar long é a abordagem padrão.