1) Fundamentos sólidos de Java e da JVM

Domine a base antes de avançar. A proficiência em Java começa pela compreensão profunda da JVM, memória, concorrência e APIs centrais.

• Arquitetura da JVM: heap, stacks, metaspace, compilação JIT, HotSpot e opt through GC.
• Modelos de memória: visibilidade, happens-before, volatılık, sincronização, locks.
• APIs centrais: java.lang, java.util (coleções, Optional, streams), java.io e java.nio (I/O assíncrona).
• Concurrência: threads, Executors, locks, concurrent collections, futuro/completable futures.
• Coleções e Streams: listas, mapas, conjuntos, pipelines funcionais, operações de redução e coleta.
• Data e hora: java.time (fusão entre API moderna de data/hora e fusos horários).
• Reflexão básica e modularidade (JPMS) para organização de grandes bases de código.

2) Java moderno: linguagem, APIs e padrões

Avance na linguagem com as novidades que entregam clareza, segurança e produtividade no dia a dia.

• Lambdas, referências a métodos e streams para processamento funcional de coleções.
• Local-variable type inference (var) e melhorias de tipagem.
• Records e classes seladas (seamless pattern matching, future-proofing de APIs).
• Pattern matching em instanceof, switch expressions e uso de Optional para evitar nulls.
• API moderna: java.time, java.util.concurrent, java.nio, java.lang.reflect com segurança.
• Construção de bibliotecas e módulos com JPMS onde fizer sentido para escalabilidade.
• Boas práticas públicas de APIs: versões estáveis, compatibilidade, documentação clara.

3) Ecossistema, arquitetura e padrões

Conheça o ecossistema e os padrões que ditam a construção de aplicações escaláveis, seguras e manteníveis.

• Spring Framework e Spring Boot: estruturação de aplicações, injeção de dependência, REST e configuração.
• Persistência: JPA/Hibernate, Spring Data, JDBC puro; design de repositórios e DTOs.
• Arquiteturas: Clean Architecture, DDD, RESTful APIs, GraphQL como opção em cenários específicos.
• Design patterns relevantes: Fábrica, Estratégia, Decorador, Observer, Builder e Adapter.
• Testes: JUnit 5, Mockito, tests de unidade/integration, contract testing e mocking estratégico.
• Segurança: autenticação/autorização (JWT, OAuth2), bcrypt, validação, headers e CORS.
• Integração com bancos de dados, mensageria (JMS, Kafka) e pipelines de dados simples.

4) Práticas de entrega, qualidade e performance

Como transformar conhecimento em código confiável, entregue rapidamente e com observabilidade.

• Builds e dependências: Maven ou Gradle, BOMs, cache de build e empacotamento (jar/war/pex).
• Testes: estratégias de unit, integration e contract testing; fixtures e dados reais com segurança.
• CI/CD: pipelines, testes automatizados, security scans, versionamento e artefatos imutáveis.
• Contêineres: Dockerfiles simples, image layering, multi-stage builds; orquestração com Kubernetes quando aplicável.
• Observabilidade: logs estruturados (SLF4J), métricas (Micrometer), tracing (OpenTelemetry).
• Performance e tuning: tuning de JVM (-Xms/-Xmx, GC G1/ZGC), profiling e análise de memory leaks.
• Resiliência e disponibilidade: circuit breakers, retries, rate limiting, circuit breaker patterns com Resilience4j.

Bloco de código relevante: Java 17+ com Records e Optional

Exemplo simples que utiliza records para Modelos imutáveis e Optional para navegação segura de dados aninhados.

// Java 17+ example: Records and Optional for safe nested access
public record Address(String city) {}

public record Person(String name, Address address) {}

import java.util.Optional;

public class Demo {
  public static String cityOf(Person p) {
    return Optional.ofNullable(p)
                   .map(Person::address)
                   .map(Address::city)
                   .orElse("UNKNOWN");
  }

  public static void main(String[] args) {
    Person p = new Person("Ana", new Address("São Paulo"));
    System.out.println(cityOf(p)); // São Paulo
  }
}