Visão Geral — Java

Três siglas que confundem todo mundo no início:

Relação: JDK ⊃ JRE ⊃ JVM

Quem usa o quê:

• Quem só executa Java (servidor de produção, usuário final): precisa do JRE
• Quem desenvolve em Java (programador, build server): precisa do JDK
• A JVM é o coração — parte tanto do JRE quanto do JDK

Detalhe histórico: a partir do Java 11, a Oracle parou de distribuir o JRE separadamente — agora você baixa o JDK e ponto.

Java tem 3 pilares que moldam o jeito de programar:

Tipagem estática

Toda variável tem um tipo declarado em compile-time. O compilador pega erros de tipo antes do código rodar. IDEs conseguem dar autocomplete completo e refatoração segura.

String nome = "João";
int idade = 30;
nome = 42;  // ERRO de compilação — int não é String

Orientação a objetos

Tudo é classe (exceto tipos primitivos: int, long, boolean, double, char, byte, short, float). Herança, polimorfismo, encapsulamento, abstração — os 4 pilares da POO, detalhados no próximo card da trilha.

Garbage collector

Você não precisa liberar memória manualmente (sem free() como em C). O GC roda em background, identifica objetos sem referência e limpa. Mais detalhe no card "Coletor de Lixo".

Outros traços

• Verboso — comparado a Python ou Kotlin, Java exige mais código pra mesma coisa. Trade-off pela explicitude.
• Multi-threaded de fábrica — Thread, synchronized, volatile, concurrent collections fazem parte da linguagem.
• Backward compatibility forte — código de Java 8 ainda roda em Java 21 sem mudança (na maioria dos casos).

Java domina vários nichos:

Sistemas corporativos / Enterprise

Bancos, seguradoras, telecom, governo. Sistemas que rodam há 10-20 anos sem reescrever. Stack típica: Spring + Tomcat + Oracle/PostgreSQL. Java é a "linguagem segura" — compila tudo, tem tipagem forte, é estável.

Android

Foi a linguagem oficial do Android até 2017, quando o Google promoveu o Kotlin a "linguagem preferida". Mas Java ainda roda em milhões de apps existentes — Kotlin compila pra bytecode JVM, então convivem.

Big data

Hadoop, Spark, Kafka, Flink, Cassandra — tudo Java/JVM. A JVM é otimizada pra throughput, as ferramentas são maduras e o ecossistema é gigante.

Backend web

APIs REST, microsserviços. Frameworks: Spring Boot (líder), Quarkus (cloud-native), Micronaut. Servidores: Tomcat, Jetty, Netty.

IDEs e ferramentas

IntelliJ IDEA, Eclipse, NetBeans, Android Studio — todos escritos em Java. Build tools: Maven, Gradle, Ant.

Onde Java NÃO domina

• Frontend (HTML/CSS/JS)
• Aplicações desktop modernas (Electron, .NET dominam)
• Mobile iOS (Swift)
• Data science / ML (Python)
• Scripts curtos / DevOps (Python, Go, Bash)

Em 2026, Java continua entre as 3 linguagens mais usadas no mundo nos rankings TIOBE e GitHub Octoverse.

Os próximos cards aprofundam tópicos que essa Visão Geral só tocou:

Card 2 — Classes e Objetos

O que é uma classe (molde) vs objeto (instância). Atributos, métodos, construtores, modificadores de acesso. A base pra entender qualquer código Java.

Card 3 — Os 4 Pilares da POO

Encapsulamento, herança, polimorfismo, abstração. Como cada pilar aparece em código real e quando usar cada um.

Card 4 — Coletor de Lixo

Como a JVM decide quais objetos limpar. Tipos de GC (Serial, G1, ZGC) e como isso afeta performance.

A trilha vai do conceito básico (o que é Java) até detalhes internos (como a JVM gerencia memória). Cada card é independente — você pode pular pra um específico se quiser.

Antes de Java 9 (2017), os releases eram longos e irregulares. Entre Java 6 (2006) e Java 7 (2011) passaram 5 anos. Entre Java 7 e 8 (2014), mais 3 anos. Cada release acumulava muita coisa nova de uma vez.

A partir de Java 9, a Oracle adotou um modelo de cadência fixa:

• Feature releases — toda primavera (março) e outono (setembro), 6 meses fixos
• LTS releases (Long-Term Support) — a cada 2-3 anos, com suporte estendido (8+ anos)

A maioria dos projetos pula as feature releases e fica nas LTS. Por isso, na prática, as versões importantes pra estudar e usar em produção são: 8, 11, 17, 21.

Features novas geralmente entram primeiro em preview (em feature releases), passam por 1-2 ciclos de feedback, e só então finalizam numa LTS. Quando você adota uma LTS, as features dela já foram testadas por 6-12 meses na comunidade.

Lançado em março de 2014, Java 8 é considerado o release que mais transformou a linguagem. Antes dele, Java era visto como verboso e datado. Java 8 trouxe vários conceitos modernos de uma vez.

Lambdas — programação funcional chega ao Java

// Antes (Java 7) — anonymous inner class verbosa
Comparator<String> cmp = new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
};

// Depois (Java 8) — lambda
Comparator<String> cmp = (a, b) -> a.length() - b.length();

Streams API — manipulação funcional de coleções

List<String> nomesAdultos = pessoas.stream()
    .filter(p -> p.getIdade() >= 18)
    .map(Pessoa::getNome)
    .collect(Collectors.toList());

Antes você fazia tudo isso com loops for aninhados e listas auxiliares. Com Streams, expressa o o quê e não o como.

Optional — alternativa explícita a null

Optional<User> user = userRepository.findById(id);
user.ifPresent(u -> System.out.println(u.getName()));

Força a tratar a ausência de valor — reduz NullPointerException.

Nova Date/Time API (java.time)

Substitui o desastroso java.util.Date e Calendar. Imutável, thread-safe, API limpa.

LocalDate hoje = LocalDate.now();
LocalDate amanha = hoje.plusDays(1);

Default methods em interfaces

public interface Lista<T> {
    void add(T item);

    default boolean isEmpty() {  // método com implementação
        return size() == 0;
    }
}

Permite adicionar métodos a interfaces sem quebrar implementações existentes — sem isso, as Streams API não seriam possíveis (Collection.stream() é default method).

Java 8 é o release mais usado em produção até hoje. Quase 12 anos depois, milhões de sistemas continuam nessa versão — o tópico do próximo accordion.

Em 2026, mais de 30% dos sistemas Java em produção ainda rodam Java 8. Os motivos são técnicos, financeiros e culturais.

1. Suporte estendido até 2030+

A Oracle estendeu o suporte do Java 8 várias vezes. Premier Support vai até dezembro de 2030. Extended Support até 2032. Empresas grandes não têm pressa.

2. Mudança de licença em Java 11

Em 2018, a Oracle mudou a licença do Oracle JDK — uso em produção passou a exigir licença comercial. Muitas empresas não queriam pagar nem migrar pro OpenJDK (gratuito), então ficaram em Java 8.

Hoje há várias distribuições gratuitas de OpenJDK 11+ (Adoptium/Temurin, Amazon Corretto, Microsoft OpenJDK), mas o trauma da licença marcou o ecossistema.

3. Trauma do Java 9 — Module System

Java 9 trouxe o sistema de módulos (Project Jigsaw), que mudou drasticamente como o classpath funciona. Bibliotecas que usavam reflection pra acessar internals da JVM quebraram. Frameworks grandes (Lombok, Mockito, Hibernate) precisaram de updates pra compatibilidade. Migrar de 8 pra 9+ exigia trabalho não trivial.

4. Java 11 removeu módulos Java EE

JAXB, JTA, CORBA, Java Web Start, Activation — tudo removido. Código que usava precisava adicionar dependências externas. Mais trabalho.

5. "Se funciona, não mexe"

Sistemas legados gigantes (banco, governo, telecom):

• Milhões de linhas de código
• Configurações certificadas
• Suite de testes pesada
• Janelas de manutenção raras
• Risco enorme em qualquer migração

Pra esses sistemas, Java 8 é "good enough" — tem lambdas, streams, Optional. As features novas (records, virtual threads) são desejáveis mas não urgentes.

6. Inércia de fornecedores

Frameworks corporativos antigos (versões antigas de Spring, Struts, EJB) só rodam em Java 8. Bibliotecas internas das empresas idem. Atualizar tudo isso é projeto, não tarefa.

Resultado: Java 8 ainda é maioria em produção legacy, enquanto Java 17 e 21 dominam projetos novos. A migração é gradual e provavelmente vai durar mais 5-10 anos.

Lançado em setembro de 2018, é o primeiro LTS após a mudança pro ciclo de 6 meses. Adoção foi mais lenta que Java 8 (problemas de licença, módulos), mas hoje é versão estável e popular.

var — inferência de tipo local

// Antes
ArrayList<Map<String, List<Integer>>> dados = new ArrayList<Map<String, List<Integer>>>();

// Depois
var dados = new ArrayList<Map<String, List<Integer>>>();

Funciona apenas em variáveis locais (não em campos, parâmetros, retorno). Adicionado em Java 10, mas popularizado no 11 — primeiro LTS a tê-lo.

HTTP Client API padronizado

Antes era HttpURLConnection (verboso, datado) ou bibliotecas externas (Apache HttpClient, OkHttp). Java 11 trouxe um cliente moderno:

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.exemplo.com"))
    .GET()
    .build();
HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

Suporta HTTP/2, requisições assíncronas (sendAsync), WebSocket.

Métodos novos em String

• lines() — converte string multilinha em Stream
• strip() — versão Unicode-aware do trim()
• repeat(n) — repete a string n vezes
• isBlank() — true se vazia ou só espaços

Files API

String conteudo = Files.readString(Path.of("arquivo.txt"));
Files.writeString(Path.of("saida.txt"), "novo conteudo");

Single-file source-code launcher

java HelloWorld.java   # sem precisar compilar primeiro

Útil pra scripts e prototipagem.

O que foi removido

• Módulos Java EE (JAXB, JAX-WS, CORBA, JTA) — virou Jakarta EE (projeto da Eclipse Foundation)
• Java Web Start, Applets — tecnologias mortas
• Nashorn (engine JavaScript) — depreciado, removido em Java 15

Lançado em setembro de 2021, Java 17 é o release que mais avançou em sintaxe moderna desde Java 8. Várias features que ficaram em preview por anos finalmente estáveis.

Records — POJO em 1 linha

// Antes — boilerplate gigante
public class Point {
    private final int x;
    private final int y;
    public Point(int x, int y) { this.x = x; this.y = y; }
    public int x() { return x; }
    public int y() { return y; }
    @Override public boolean equals(Object o) { /* ... */ }
    @Override public int hashCode() { /* ... */ }
    @Override public String toString() { /* ... */ }
}

// Depois — 1 linha
public record Point(int x, int y) {}

Records são imutáveis e geram automaticamente: construtor, getters, equals, hashCode, toString.

Sealed classes — controle de hierarquia

public sealed class Forma permits Circulo, Quadrado, Triangulo {}
public final class Circulo extends Forma {}
public final class Quadrado extends Forma {}
public final class Triangulo extends Forma {}

Limita quem pode estender. Útil pra modelar tipos algébricos (ADTs) e melhorar pattern matching.

Pattern matching for instanceof

// Antes
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// Depois
if (obj instanceof String s) {
    System.out.println(s.length());
}

Text blocks — strings multilinhas

String json = """
    {
        "name": "Joao",
        "age": 30
    }
    """;

Indentação automática, ideal pra JSON, SQL, HTML inline.

Switch expressions

String dia = switch (numero) {
    case 1 -> "Segunda";
    case 2 -> "Terca";
    case 3 -> "Quarta";
    default -> "Outro";
};

Switch que retorna valor, sem fallthrough acidental, exhaustive (compila erro se faltar caso).

Java 17 é a versão "default" pra projetos novos hoje em muitas empresas. Substituiu Java 8 sem dor de cabeça (pulou direto sem 11, em muitos casos).

Lançado em setembro de 2023, Java 21 tem uma feature-estrela: virtual threads. Muda o jogo pra servidores web e qualquer aplicação com muitas threads.

Virtual threads — milhões de threads leves

O modelo antigo:

• Threads do SO custam memória (~1 MB cada de stack)
• Limite prático: ~10 mil threads por JVM
• Pra escalar, você precisava de async/reactive (CompletableFuture, Reactor) — código difícil de ler e debugar

O modelo novo:

• Virtual threads são gerenciadas pela JVM, não pelo SO
• Custam ~kB cada — milhões viáveis
• Permite escrever código bloqueante (síncrono) com performance de async

// Cria virtual thread por requisicao — escala como Node.js, com sintaxe sincrona
Thread.startVirtualThread(() -> {
    handleRequest(req);  // pode bloquear sem problema
});

Game changer pra servidores web, microsserviços, qualquer thing-per-request.

Sequenced collections

Interfaces unificadas (SequencedCollection, SequencedSet, SequencedMap) pra coleções com ordem definida — List, LinkedHashSet, LinkedHashMap.

List<String> lista = List.of("a", "b", "c");
String primeiro = lista.getFirst();          // "a"
String ultimo = lista.getLast();             // "c"
List<String> reverso = lista.reversed();    // ["c", "b", "a"]

Pattern matching for switch

String desc = switch (obj) {
    case Integer i when i > 0 -> "positivo";
    case Integer i -> "nao positivo";
    case String s -> "string " + s;
    case null -> "nulo";
    default -> "outro tipo";
};

Record patterns

if (point instanceof Point(int x, int y)) {
    // x e y desestruturados direto
    System.out.println(x + ", " + y);
}

Java 21 é a versão atual recomendada pra projetos novos. Quem está em Java 17 sem features específicas do 21 não tem urgência pra migrar.

Próxima LTS: Java 29 (setembro de 2027). A partir do próximo ciclo, novas LTS a cada 2 anos (em vez de 3).