roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Answer Java language rounds at interview depth, before any framework. Covers syntax and the type system, core APIs, concurrency, the JVM and garbage collection, and Maven, Gradle and JUnit basics.
2561 of 2561 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 2561 new. 0 cut, outside your plan.
A job title without the word Java does not keep the language out of the interview: backend, test automation and data engineering loops on the JVM all ask about it. They land in the coding round, where the language you solve in is itself being read, and in a language conversation that often follows the screen, built from small exact puzzles: why two boxed `Integer` values of 127 are equal under `==` and two of 128 are not, why removing an element inside a for-each loop can throw `ConcurrentModificationException`, why a `String[]` passes for an `Object[]` but a `List<String>` will not pass for a `List<Object>`, why a `return` inside `finally` makes an exception vanish. Level decides where the follow-ups go. In the junior band they ask for the rule behind the puzzle: the boxing cache, erasure, fail-fast iterators. Above it they arrive as symptoms from the runtime: a worker loop that never sees the stop flag another thread cleared, a `parallelStream` of blocking calls that slows unrelated streams because they share one common pool, a `Metaspace` `OutOfMemoryError` after repeated redeploys. From senior level up, the answer that counts names the evidence first, the heap dump, GC log or profiler output that would confirm the cause, and only then a fix. At any level, answers that never reach records, sealed types or virtual threads read as dated.
Plain language fills the opening module: [the basic constructs](/topics/lang-java-fundamentals), the initialization order and string identity of the core features, and [exception handling](/topics/lang-java-exceptions), placed this early because nearly every API after it throws something. Classes & Type System then builds the object model up to [the contracts of `Object`](/topics/lang-java-oop-object-contracts), and only then [generics](/topics/lang-java-generics), whose bounds and wildcards are written against the class hierarchy just learned. Core APIs spends that groundwork. A [collection](/topics/lang-java-collections) is a generic type whose correctness rests on `equals`, `hashCode` and `compareTo`, so it cannot come sooner. The module then widens to the rest of the platform and ends at [JDBC](/topics/be-jdbc), the only place this plan touches a database, through the driver API with nothing on top. [Lambdas and streams](/topics/lang-java-functional) follow because a stream starts from a collection and a lambda is an instance of a functional interface, which is generics again. With Threads & Visibility the questions stop being about what a line means and start being about what the running program does. [Concurrency](/topics/lang-java-concurrency) comes first and the [memory model](/topics/lang-jvm-memory-model) right behind it, since happens-before is what explains why a write under a lock or to a `volatile` field becomes visible and an unguarded one may not. JVM Internals shows the machine those rules are written for: [class loading](/topics/lang-jvm-classloading), where a library compiled against one version and run against another fails with `NoSuchMethodError`, and the [JIT](/topics/lang-jvm-jit), whose reordering is what the memory model permits and whose optimizations make a naive microbenchmark lie. Memory & GC lays out the heap before the [collectors](/topics/lang-jvm-gc), and Tuning & Diagnostics puts all of it to work, from heap sizing through [leaks and reference types](/topics/lang-java-jvm-memory) to profiling. Idioms & Secure Coding returns to code, now with the runtime behind it: [immutability](/topics/lang-java-design-immutability) is argued from the memory model's guarantee for final fields. Build and test tooling closes the plan, kept to what interviews ask of it, such as why Maven's [nearest-wins mediation](/topics/dev-maven-dependencies) can choose a version that later fails at run time, and how [JUnit and Mockito](/topics/lang-java-testing) tests are put together.
For a first Java job, the four modules up to Lambdas & Streams carry most of a junior loop, so read them whole and in sequence, which is what by topics does to study order; level can lose its upper bands, since junior rounds rarely leave the language and its collections. A senior candidate should leave the bottom of level open instead, because the boxing, initialization and erasure puzzles of the first modules are asked at every level and are easy to fumble cold, then spend most hours between Threads & Visibility and Tuning & Diagnostics, having read at least one real heap dump and GC log. From C#, two habits mislead: generics here are erased, so a type argument is gone at run time, and checked exceptions force a decision about `throws` that C# never asks for. Classes & Type System and exception handling deserve a slow pass. The plan stops short of application frameworks and algorithm drills. Spring, ORM persistence and the system design round belong to the [Java Backend Developer roadmap](/roadmaps/java-developer), which opens on this language and builds the job around it; the problems a coding round sets are practiced on the [Data Structures & Algorithms roadmap](/roadmaps/datastructures-and-algorithms).
A job title without the word Java does not keep the language out of the interview: backend, test automation and data engineering loops on the JVM all ask about it. They land in the coding round, where the language you solve in is itself being read, and in a language conversation that often follows the screen, built from small exact puzzles: why two boxed Integer values of 127 are equal under == and two of 128 are not, why removing an element inside a for-each loop can throw ConcurrentModificationException, why a String[] passes for an Object[] but a List<String> will not pass for a List<Object>, why a return inside finally makes an exception vanish.
Level decides where the follow-ups go. In the junior band they ask for the rule behind the puzzle: the boxing cache, erasure, fail-fast iterators. Above it they arrive as symptoms from the runtime: a worker loop that never sees the stop flag another thread cleared, a parallelStream of blocking calls that slows unrelated streams because they share one common pool, a Metaspace OutOfMemoryError after repeated redeploys. From senior level up, the answer that counts names the evidence first, the heap dump, GC log or profiler output that would confirm the cause, and only then a fix. At any level, answers that never reach records, sealed types or virtual threads read as dated.
Plain language fills the opening module: the basic constructs, the initialization order and string identity of the core features, and exception handling, placed this early because nearly every API after it throws something. Classes & Type System then builds the object model up to the contracts of Object, and only then generics, whose bounds and wildcards are written against the class hierarchy just learned.
Core APIs spends that groundwork. A collection is a generic type whose correctness rests on equals, hashCode and compareTo, so it cannot come sooner. The module then widens to the rest of the platform and ends at JDBC, the only place this plan touches a database, through the driver API with nothing on top. Lambdas and streams follow because a stream starts from a collection and a lambda is an instance of a functional interface, which is generics again.
With Threads & Visibility the questions stop being about what a line means and start being about what the running program does. Concurrency comes first and the memory model right behind it, since happens-before is what explains why a write under a lock or to a volatile field becomes visible and an unguarded one may not. JVM Internals shows the machine those rules are written for: class loading, where a library compiled against one version and run against another fails with NoSuchMethodError, and the JIT, whose reordering is what the memory model permits and whose optimizations make a naive microbenchmark lie. Memory & GC lays out the heap before the collectors, and Tuning & Diagnostics puts all of it to work, from heap sizing through leaks and reference types to profiling.
Idioms & Secure Coding returns to code, now with the runtime behind it: immutability is argued from the memory model's guarantee for final fields. Build and test tooling closes the plan, kept to what interviews ask of it, such as why Maven's nearest-wins mediation can choose a version that later fails at run time, and how JUnit and Mockito tests are put together.
For a first Java job, the four modules up to Lambdas & Streams carry most of a junior loop, so read them whole and in sequence, which is what by topics does to study order; level can lose its upper bands, since junior rounds rarely leave the language and its collections. A senior candidate should leave the bottom of level open instead, because the boxing, initialization and erasure puzzles of the first modules are asked at every level and are easy to fumble cold, then spend most hours between Threads & Visibility and Tuning & Diagnostics, having read at least one real heap dump and GC log.
From C#, two habits mislead: generics here are erased, so a type argument is gone at run time, and checked exceptions force a decision about throws that C# never asks for. Classes & Type System and exception handling deserve a slow pass.
The plan stops short of application frameworks and algorithm drills. Spring, ORM persistence and the system design round belong to the Java Backend Developer roadmap, which opens on this language and builds the job around it; the problems a coding round sets are practiced on the Data Structures & Algorithms roadmap.