Java Versões e LTS

O Java muda: a cada seis meses sai uma versão nova, com recursos novos e correções. Algumas dessas versões são especiais, as LTS, que recebem atualizações por muitos anos e são as que as empresas usam. Nesta aula você aprende a descobrir qual Java tem no computador, a ler o número da versão e a saber por que um código que funciona aqui pode não compilar no computador de outra pessoa.

A ideia: modelos de carro e revisões

Pense numa montadora de carros. Todo ano sai um modelo novo, com novidades. A maioria das pessoas não troca de carro todo ano; troca a cada vários anos e, enquanto isso, leva o carro para as revisões, que corrigem problemas sem mudar o modelo. A montadora promete peças e revisões por mais tempo só para alguns modelos, os mais vendidos.

O Java funciona assim:

• Cada versão (Java 21, 22, 23…) é um modelo novo, com recursos novos na linguagem e na biblioteca.
• As atualizações (25.0.1, 25.0.2…) são as revisões: corrigem falhas de segurança e defeitos, sem recursos novos.
• As versões LTS (de Long-Term Support, "suporte de longo prazo") são os modelos com revisões garantidas por muitos anos. As outras recebem atualizações só por seis meses, até sair a próxima.

Qual Java está instalado?

O primeiro comando para qualquer problema com Java é perguntar a versão:

java

O lançador do Java, o mesmo que executa programas.

-version

Uma opção: em vez de rodar um programa, "mostre a versão". O traço único é o estilo antigo, que funciona em todas as versões do Java.

$ java -version
openjdk version "25.0.4.1" 2026-08-18 LTS                  « a versão, a data de lançamento e LTS
OpenJDK Runtime Environment Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS)     « a distribuição: Temurin
OpenJDK 64-Bit Server VM Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS, mixed mode, sharing)   « a JVM

Três linhas, uma para cada coisa:

1. A versão do Java: openjdk version "25.0.4.1", lançada em 2026-08-18, uma LTS. O openjdk diz que ela vem do projeto OpenJDK (no Oracle JDK aparece java version).
2. O ambiente de execução (Runtime Environment, o JRE que vem dentro do JDK) e quem o montou: Temurin.
3. A máquina virtual: 64-Bit Server VM (a JVM para computadores de 64 bits), em mixed mode (interpretador + JIT, veja O que é Java) e com sharing (compartilha classes já carregadas para iniciar mais rápido).

Três jeitos de perguntar

$ java --version
openjdk 25.0.4.1 2026-08-18 LTS
OpenJDK Runtime Environment Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS, mixed mode, sharing)
$ javac -version
javac 25.0.4.1                     « a versão do compilador
$ jshell --version
jshell 25.0.4.1

A diferença entre "saída de erro" e "saída normal" parece detalhe, mas aparece quando você joga a resposta fora ou a passa para outro comando. O 2>/dev/null descarta a saída de erro; o >/dev/null descarta a saída normal:

$ java -version 2>/dev/null
$ java --version > /dev/null       « nenhum dos dois mostra nada
$ java -version 2>&1 | head -1
openjdk version "25.0.4.1" 2026-08-18 LTS   « 2>&1 junta a saída de erro à normal

Se um dia você precisar da versão dentro de um script, use java -version 2>&1 ou java --version. As duas saídas de um programa são assunto de Saída: print e println.

Lendo o número da versão

Desde o Java 10, o número segue o formato RECURSO.INTERINO.ATUALIZAÇÃO.CORREÇÃO+BUILD. Desmontando 25.0.4.1+1-LTS:

25

A versão de recursos (feature): o "modelo do carro". É o número que todo mundo usa: "Java 25".

.0

Versão interina: quase sempre 0 (é reservada para casos raros).

.4

A atualização (update): a quarta revisão de segurança do Java 25. Sai a cada três meses (janeiro, abril, julho e outubro).

.1

Uma correção (patch) urgente em cima da atualização 4.

+1

O número da compilação (build) feita pela distribuição.

-LTS

Marca que esta é uma versão de suporte longo.

O Java 8 tem outro jeito: 1.8

Até o Java 8, o número oficial começava com 1.: o Java 8 é o "1.8", o Java 7 é o "1.7". Na máquina da Ana também há um Java 8 e um Java 21 instalados pelo sistema (você vai ver por que em Várias versões). Compare:

$ /usr/lib/jvm/java-8-openjdk-amd64/bin/java -version
openjdk version "1.8.0_504"                            « Java 8, atualização 504
OpenJDK Runtime Environment (build 1.8.0_504-8u504-ga-1ubuntu1~26.04.3-b01)
OpenJDK 64-Bit Server VM (build 25.504-b01, mixed mode)        « este "25" é da JVM antiga, não é Java 25!
$ /usr/lib/jvm/java-21-openjdk-amd64/bin/java -version
openjdk version "21.0.12.1" 2026-08-18
OpenJDK Runtime Environment (build 21.0.12.1+1-1-26.04.4-Ubuntu)
OpenJDK 64-Bit Server VM (build 21.0.12.1+1-1-26.04.4-Ubuntu, mixed mode, sharing)

1.8.0_504 quer dizer "Java 8, atualização 504"; você vai ver isso escrito como 8u504 em muitos lugares. Cuidado com a terceira linha: o 25.504 é o número interno da máquina virtual do Java 8 e não tem nada a ver com o Java 25. Olhe sempre a primeira linha.

Repare também que o pacote do Ubuntu não escreve LTS na versão, mesmo sendo o 21 uma versão LTS: essa marca é opcional e cada distribuição decide se a mostra.

O ciclo de seis meses

Até 2017, uma versão nova do Java saía quando ficava pronta, às vezes depois de três ou quatro anos de espera (o Java 8 é de 2014; o 9, de 2017). Desde o Java 10, em 2018, o calendário é fixo: uma versão nova em março e outra em setembro, todo ano. O que não ficou pronto a tempo espera a próxima.

De dois em dois anos, a versão de setembro é LTS. As demais são versões "de passagem": recebem atualizações por seis meses e depois são abandonadas, porque a seguinte já saiu.

Por que o guia usa o 25, e não o 27?

O Java 27 é mais novo, mas é uma versão comum: em março de 2027 ele deixa de receber atualizações. O Java 25 recebe atualizações por anos, é o que as empresas estão adotando e é o que você vai encontrar nos empregos e nos cursos. Tudo o que você aprender aqui funciona igual nas versões 26 e 27, porque o Java quase nunca remove recursos da linguagem.

O que cada LTS trouxe

Um resumo do que mais importa para quem está aprendendo. Cada versão LTS inclui tudo das anteriores. Não se preocupe com os nomes agora: cada recurso tem a sua aula, e a aula Novidades do Java 17 ao 25 aprofunda as versões recentes.

Para ver a diferença na prática, este programa usa três recursos de versões diferentes. Cada um está marcado com o selo da versão em que apareceu:

• var nome = "Ana"; — o Java descobre sozinho o tipo da variável Java 10+.
• o texto entre """ — um text block, texto de várias linhas Java 15+.
• "=".repeat(20) — repete um texto 20 vezes Java 11+.

public class Main {
    public static void main(String[] args) {
        var nome = "Ana";
        String recibo = """
            Loja da Ana
            Cliente: %s
            """.formatted(nome);
        System.out.print(recibo);
        System.out.println("=".repeat(20));
    }
}

$ java Main.java
Loja da Ana
Cliente: Ana
====================

No Java 25 tudo funciona. Agora a Ana pede ao javac para compilar como se fosse o Java 11, com a opção --release 11 ("gere código para o Java 11 e só aceite o que existia nele"):

$ javac --release 11 Main.java
Main.java:4: error: text blocks are not supported in -source 11
        String recibo = """
                        ^
  (use -source 15 or higher to enable text blocks)
1 error

A mensagem é clara: "text blocks não são suportados no Java 11; use 15 ou maior". O var e o repeat passaram, porque já existiam no 11. É exatamente isso que acontece quando você copia um exemplo moderno e tenta compilar num Java antigo: o javac diz qual recurso não existe e a partir de qual versão ele existe.

public class Main {
    public static void main(String[] args) {
        System.out.println("Loja da Ana");
        System.out.println("=".repeat(20));
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Loja da Ana");
        System.out.println("*".repeat(20));
    }
}

Por que empresas ainda usam Java 8, 11 e 17

Se o Java 25 é melhor, por que tantas vagas pedem "Java 8" ou "Java 11"? Porque trocar a versão de um sistema grande não é como atualizar o celular:

• Custo e risco. Um banco tem milhões de linhas de código funcionando. Mudar a versão exige testar tudo de novo. Enquanto o sistema funciona e recebe atualizações de segurança, a empresa adia a mudança.
• Bibliotecas e servidores antigos. O sistema depende de bibliotecas que só funcionam até certa versão. Atualizar o Java obriga a atualizar essas peças também.
• Mudanças do Java 9 e 11. O Java 9 trouxe os módulos, e o Java 11 removeu partes antigas da biblioteca (como algumas de XML e de sistemas corporativos). Muitos sistemas travaram nessa passagem e ficaram no 8.
• Suporte longo. Várias distribuições ainda publicam atualizações de segurança para o 8, o 11 e o 17, então ficar neles continua seguro por um tempo.

A boa notícia: quem aprende Java 25 lê sem dificuldade um código de Java 8. O contrário é que dá trabalho, porque o Java 8 não conhece var, records, text blocks nem o switch com setas. Por isso as aulas marcam esses recursos com o selo de versão.

O selo de versão do guia

Quando um recurso não existe em todas as versões do Java, a aula mostra um selo com a versão mínima:

Recursos sem selo existem pelo menos desde o Java 8. Se você está usando o Java 17 ou o 21, quase todo o Nível 1 funciona sem mudança.

Quando dá errado

$ javac --release 11 Main.java
Main.java:4: error: text blocks are not supported in -source 11
        String recibo = """
                        ^
  (use -source 15 or higher to enable text blocks)
1 error

$ javac --release 8 Main.java
warning: [options] source value 8 is obsolete and will be removed in a future release
warning: [options] target value 8 is obsolete and will be removed in a future release
warning: [options] To suppress warnings about obsolete options, use -Xlint:-options.
3 warnings

public class Main {
    public static void main(String[] args) {
        System.out.println("Java 8 é LTS");
        System.out.println("Java 17 é LTS");
        System.out.println("Java 21 é LTS");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Java 8 é LTS");
        System.out.println("Java 17 é LTS");
        System.out.println("Java 21 é LTS");
        System.out.println("Java 25 é LTS");
    }
}

Exercícios

Resumo

• java -version e javac -version mostram a versão; confira que os dois concordam.
• 25.0.4.1+1-LTS = Java 25, atualização 4, correção 1, build 1, versão LTS. O Java 8 se escreve 1.8.0_….
• Uma versão nova a cada seis meses (março e setembro); uma LTS a cada dois anos.
• LTS: 8 (2014), 11 (2018), 17 (2021), 21 (2023) e 25 (2025). O guia ensina o 25.
• Empresas ficam em versões antigas por custo, risco e bibliotecas; o código antigo é fácil de ler para quem aprendeu o novo.
• O selo Java 21+ marca recursos novos; a aula sempre mostra a alternativa.