Skip to main content

Learning path

Java learning path: everything to study, topic by topic

Comprehensive Java assessment covering language fundamentals, core APIs, concurrency, JVM internals, frameworks, and modern Java features.

Short answer

To learn Java, work through 6 modules and 33 topics in the order they build on each other. It starts with Language Fundamentals, then moves on to Core Java and Concurrency. Use the map as a checklist, or measure your level and study only what is missing.

6
modules
33
topics
45
min to assess

What you will study

Topics are grouped by module. Open one to see its objectives and key concepts.

1 · Language Fundamentals5 topics
  • Types & Operators

    Primitive types, wrapper classes, autoboxing, type promotion, and operator precedence

    Objectives

    • Distinguish primitives from wrapper classes
    • Predict type promotion and autoboxing behaviour

    Key concepts

    • primitive types
    • wrapper classes
    • autoboxing
    • type promotion
    • operator precedence
    • var keyword
  • Control Flow

    If/else, switch expressions, loops, enhanced for, pattern matching, and labeled breaks

    Objectives

    • Use modern switch expressions correctly
    • Predict loop and branch execution flow

    Key concepts

    • switch expressions
    • pattern matching
    • enhanced for
    • labeled break
    • short-circuit evaluation
  • OOP Basics

    Classes, interfaces, inheritance, polymorphism, sealed classes, and records

    Objectives

    • Apply inheritance and polymorphism correctly
    • Choose between interfaces, abstract classes, and records

    Key concepts

    • inheritance
    • polymorphism
    • interfaces
    • abstract classes
    • sealed classes
    • records
    • encapsulation
  • Exception Handling

    Checked vs unchecked exceptions, try-with-resources, custom exceptions, and best practices

    Objectives

    • Distinguish checked from unchecked exceptions
    • Use try-with-resources for safe resource management

    Key concepts

    • checked exceptions
    • unchecked exceptions
    • try-with-resources
    • custom exceptions
    • exception chaining
    • AutoCloseable
  • Documentation

    Javadoc syntax, tags, package-info, generating HTML docs, and code examples in documentation

    Objectives

    • Write complete Javadoc with proper tags for public APIs
    • Generate and navigate HTML documentation from source code

    Key concepts

    • Javadoc syntax
    • @param tag
    • @return tag
    • @throws tag
    • package-info.java
    • generating HTML docs
    • code examples in docs
    • @see and @link
2 · Core Java5 topics
  • Collections Framework

    List, Set, Map implementations, iteration, Comparable/Comparator, and Collections utility

    Objectives

    • Choose the right collection for a given scenario
    • Understand time complexity of common operations

    Key concepts

    • ArrayList
    • LinkedList
    • HashMap
    • TreeMap
    • HashSet
    • Comparable
    • Comparator
    • Collections utility
  • Generics

    Type parameters, bounded types, wildcards, type erasure, and generic methods

    Objectives

    • Apply PECS for wildcard usage
    • Explain type erasure implications

    Key concepts

    • type parameters
    • bounded types
    • upper/lower wildcards
    • type erasure
    • generic methods
    • PECS principle
  • I/O & NIO

    Streams, readers/writers, Path API, channels, buffers, and file watching

    Objectives

    • Choose between IO and NIO for different use cases
    • Use Path API for modern file operations

    Key concepts

    • InputStream/OutputStream
    • Reader/Writer
    • BufferedReader
    • Files class (NIO)
    • Path API
    • Channels and Buffers
    • try-with-resources
    • serialization
  • Strings & Text

    String immutability, StringBuilder, text blocks, String pool, and formatting

    Objectives

    • Explain String immutability and pool behaviour
    • Choose between String and StringBuilder

    Key concepts

    • String immutability
    • String pool
    • StringBuilder
    • text blocks
    • String.format
    • intern()
  • Functional Programming

    Lambda expressions, Stream API, functional interfaces, method references, and Optional

    Objectives

    • Write fluent Stream pipelines with proper terminal operations
    • Choose between imperative and functional style for readability and performance

    Key concepts

    • lambda expressions
    • Stream API
    • functional interfaces
    • method references
    • Optional class
    • Collectors
    • parallel streams
    • pure functions
3 · Concurrency4 topics
  • Thread Basics

    Thread lifecycle, Runnable, Callable, ExecutorService, and thread pools

    Objectives

    • Create and manage threads using ExecutorService
    • Explain thread lifecycle states

    Key concepts

    • Thread lifecycle
    • Runnable
    • Callable
    • ExecutorService
    • thread pools
    • Future
  • Synchronized & Locks

    synchronized keyword, ReentrantLock, ReadWriteLock, deadlock prevention, and volatile

    Objectives

    • Identify and prevent deadlock scenarios
    • Choose between synchronized and explicit locks

    Key concepts

    • synchronized
    • ReentrantLock
    • ReadWriteLock
    • volatile
    • deadlock
    • lock ordering
    • happens-before
  • Concurrent Collections

    ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, and atomic variables

    Objectives

    • Select the right concurrent collection for a scenario
    • Explain CAS and lock-free approaches

    Key concepts

    • ConcurrentHashMap
    • CopyOnWriteArrayList
    • BlockingQueue
    • AtomicInteger
    • CAS operations
    • lock-free algorithms
  • CompletableFuture

    Async composition, thenApply/thenCompose, exception handling, and combining futures

    Objectives

    • Compose async pipelines with CompletableFuture
    • Handle errors in async chains

    Key concepts

    • CompletableFuture
    • thenApply
    • thenCompose
    • allOf
    • exceptionally
    • async pipelines
4 · JVM & Performance4 topics
  • JVM Memory Model

    Heap, stack, metaspace, memory areas, JMM happens-before, and memory leaks

    Objectives

    • Describe JVM memory areas and their roles
    • Identify common causes of memory leaks

    Key concepts

    • heap
    • stack
    • metaspace
    • young/old generation
    • JMM
    • happens-before
    • memory leaks
  • Garbage Collection

    GC algorithms, G1, ZGC, Shenandoah, tuning flags, and GC log analysis

    Objectives

    • Choose a GC algorithm for different workloads
    • Interpret GC logs to diagnose issues

    Key concepts

    • Serial GC
    • Parallel GC
    • G1
    • ZGC
    • Shenandoah
    • GC tuning flags
    • GC log analysis
  • Profiling & Optimization

    JFR, async-profiler, heap dumps, thread dumps, and micro-benchmarking with JMH

    Objectives

    • Use profiling tools to find performance bottlenecks
    • Write correct JMH benchmarks

    Key concepts

    • JFR
    • async-profiler
    • heap dump
    • thread dump
    • JMH
    • flame graphs
    • allocation profiling
  • Class Loading

    ClassLoader hierarchy, delegation model, custom loaders, and module system (JPMS)

    Objectives

    • Explain the classloader delegation model
    • Understand JPMS module boundaries

    Key concepts

    • bootstrap classloader
    • application classloader
    • delegation model
    • custom classloader
    • JPMS modules
    • classpath vs modulepath
5 · Frameworks & Tools5 topics
  • Spring Boot

    Auto-configuration, dependency injection, bean lifecycle, profiles, and actuator

    Objectives

    • Explain Spring Boot auto-configuration mechanics
    • Configure beans and profiles correctly

    Key concepts

    • auto-configuration
    • dependency injection
    • bean lifecycle
    • profiles
    • actuator
    • starters
    • @Configuration
  • JPA & Hibernate

    Entity mapping, relationships, JPQL, N+1 problem, caching levels, and lazy loading

    Objectives

    • Prevent N+1 query problems
    • Configure entity relationships correctly

    Key concepts

    • entity mapping
    • @OneToMany/@ManyToOne
    • JPQL
    • N+1 problem
    • first/second level cache
    • lazy vs eager
    • dirty checking
  • Testing & JUnit

    JUnit 5, Mockito, test slices, integration testing, and TDD practices

    Objectives

    • Write effective unit and integration tests
    • Use test slices for fast Spring tests

    Key concepts

    • JUnit 5
    • Mockito
    • @SpringBootTest
    • test slices
    • Testcontainers
    • TDD
    • assertion libraries
  • Build Tools

    Maven, Gradle, dependency management, multi-module projects, and CI/CD integration

    Objectives

    • Configure multi-module builds correctly
    • Manage dependency conflicts effectively

    Key concepts

    • Maven lifecycle
    • pom.xml structure
    • Gradle build scripts
    • Gradle vs Maven
    • dependency management
    • plugins
    • multi-module projects
    • Bazel basics
  • Logging

    SLF4J facade, Logback and Log4j2 configuration, logging levels, MDC, and structured logging

    Objectives

    • Configure logging frameworks with appropriate levels and appenders
    • Use MDC and structured logging for production observability

    Key concepts

    • SLF4J facade
    • Logback configuration
    • Log4j2
    • logging levels
    • MDC context
    • structured logging
    • log rotation
    • performance impact
6 · Expert Java10 topics
  • JVM Internals

    Bytecode, JIT compilation, inlining, escape analysis, and intrinsics

    Objectives

    • Explain JIT compilation tiers and optimizations
    • Predict when escape analysis applies

    Key concepts

    • bytecode
    • JIT compilation
    • C1/C2 compilers
    • inlining
    • escape analysis
    • intrinsics
    • tiered compilation
  • Microservice Patterns

    Circuit breaker, saga, API gateway, service mesh, and observability in Java ecosystems

    Objectives

    • Design resilient microservices with proper patterns
    • Implement distributed tracing and observability

    Key concepts

    • circuit breaker
    • saga pattern
    • API gateway
    • service mesh
    • distributed tracing
    • Resilience4j
    • Micrometer
  • Virtual Threads

    Project Loom, virtual vs platform threads, structured concurrency, and pinning

    Objectives

    • Explain virtual thread scheduling and pinning
    • Migrate blocking code to virtual threads

    Key concepts

    • virtual threads
    • structured concurrency
    • carrier threads
    • pinning
    • thread-per-request
    • StructuredTaskScope
  • GraalVM & Native Image

    GraalVM compiler, native image, substrate VM, reflection config, and startup optimization

    Objectives

    • Build native images and handle reflection limits
    • Compare AOT vs JIT trade-offs

    Key concepts

    • GraalVM
    • native image
    • substrate VM
    • reflection configuration
    • AOT compilation
    • closed-world assumption
    • startup time
  • JVM Internals & GC Tuning

    Understanding JVM memory model, garbage collectors (G1, ZGC, Shenandoah), and tuning for production workloads

    Objectives

    • Tune G1GC heap regions and pause targets for a latency-sensitive service
    • Interpret GC log output to diagnose pause spikes

    Key concepts

    • heap regions
    • G1GC
    • ZGC
    • Shenandoah
    • GC pause tuning
    • safepoints
    • GC logs analysis
    • -XX flags
  • Structured Concurrency & ScopedValues

    Using Java 21 structured concurrency APIs (StructuredTaskScope) and ScopedValue for context propagation in virtual thread environments

    Objectives

    • Use StructuredTaskScope.ShutdownOnFailure to fan out subtasks safely
    • Replace thread-local variables with ScopedValue in virtual-thread code

    Key concepts

    • StructuredTaskScope
    • ShutdownOnFailure
    • ShutdownOnSuccess
    • ScopedValue
    • context propagation
    • task tree lifetime
    • cancellation semantics
  • Java Memory Model & Happens-Before

    Understanding the Java Memory Model, happens-before relationships, volatile semantics, and safe publication patterns

    Objectives

    • Explain the happens-before guarantee for synchronized blocks and volatile writes
    • Identify data race conditions and apply correct safe publication patterns

    Key concepts

    • happens-before
    • volatile
    • synchronized
    • final fields
    • safe publication
    • memory visibility
    • JSR-133
    • AtomicXxx
  • Reactive Programming with Project Reactor

    Building reactive streams with Project Reactor (Flux/Mono), backpressure, schedulers, and error handling

    Objectives

    • Implement a reactive data pipeline with error handling and backpressure
    • Choose between flatMap, concatMap, and switchMap for different use cases

    Key concepts

    • Flux
    • Mono
    • backpressure
    • schedulers
    • flatMap vs concatMap
    • hot vs cold publishers
    • StepVerifier
    • WebFlux
  • Bytecode Manipulation (ASM/ByteBuddy)

    Instrumenting Java applications at bytecode level using ASM or ByteBuddy for APM agents and dynamic proxies

    Objectives

    • Instrument a method with ASM to record invocation metrics
    • Build a JavaAgent using ByteBuddy Advice to intercept method calls

    Key concepts

    • ClassVisitor
    • MethodVisitor
    • ByteBuddy
    • java.lang.instrument
    • Advice
    • dynamic proxy
    • class retransformation
  • Java Security Architecture

    Java security manager, JAAS, JCA/JCE cryptography APIs, secure coding practices, and deserialization hardening

    Objectives

    • Harden Java deserialization with ObjectInputFilter/SerialFilter
    • Use JCA/JCE APIs correctly for encryption, signing, and key management

    Key concepts

    • SecurityManager
    • JAAS
    • JCA/JCE
    • KeyStore
    • deserialization gadgets
    • SerialFilter
    • JNDI injection
    • secure random

Levels: Junior, Mid, Senior, and Expert

Explain it in your own words

Graded by AI · no account · 1 question

No options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.

0 / 600

Already studying Java?

The assessment measures topic by topic, and your plan skips what you already know.

Measure my level

Open to read. An account is only needed to be measured.

Frequently asked questions

Where should I start studying Java?

Start with Language Fundamentals: Types & Operators, Control Flow, and OOP Basics. The map orders topics by what they depend on, so each one prepares the next.

How long does a full Java assessment take?

A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.

Do I need an account to use this page?

No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.