→ Advanced Java → Spring Boot → FAANG Projects
IMPORTANT: This roadmap covers the Java language, core APIs, and ecosystem only.
Java DSA (data structures, algorithms, LeetCode strategy, contest readiness) is a separate roadmap — the next one
in the series. The two run simultaneously. As you build language fluency here, the DSA roadmap builds
problem-solving depth. They feed each other: the Collections you learn in Phase 2 here are the exact structures you
implement and use in the DSA roadmap.
COMPLETE BOOK PROGRESSION
# Book When Why
1 ProgramizPro — Java Course Phase 1 (start First step. Covers syntax and basic OOP quickly. Beginner-level
here) only — not a substitute for books.
2 Core Java Volume I — Phases 1 & 2 The most thorough modern Java textbook. ~900 pages. Covers
Fundamentals Cay S. Horstmann (primary) language fundamentals, OOP, interfaces, generics, collections, and
exceptions in serious depth. Do every exercise. This is your main
book for Phases 1 and 2.
3 Core Java Volume II — Advanced Phase 3 Continuation of Volume I. Covers streams, I/O, concurrency,
Features Cay S. Horstmann (primary) networking, and the new functional APIs. Primary book for Phase 3.
4 Effective Java, 3rd Edition Joshua Phase 2 THE Java best-practices book. 90 specific items — how to use
Bloch onward (read generics correctly, when to prefer composition over inheritance,
alongside) how to write good equals/hashCode, etc. Read one item per day
alongside your primary book.
5 Java Concurrency in Practice Goetz, Phase 3 The authoritative book on Java multithreading. Covers the Java
Peierls et al. (concurrency) Memory Model, thread safety, locks, and the [Link]
package in depth. Essential for any senior Java role.
6 Spring Boot in Action Craig Walls Phase 4 Focused, practical Spring Boot guide. Covers auto-configuration,
REST controllers, Spring Data JPA, testing with Spring. Best
introductory Spring Boot book.
7 Clean Code Robert C. Martin Phase 3 Language-agnostic but written with Java examples. Covers naming,
onward functions, classes, and refactoring. Read this when your projects
get large enough to feel messy.
FREE WEBSITES & PRACTICE PLATFORMS (NO YOUTUBE)
Website Best for What to use it for
[Link]/javase/tutorial All phases The official Java tutorials from Oracle. Thorough, reliable, and well-structured
by topic. Use this alongside Horstmann for any topic that needs a second
angle.
[Link] All phases Best Java-focused tutorial website. Covers core Java, Spring Boot, Hibernate,
testing, and more in serious depth. Every article is long-form and technical.
[Link]/tracks/java Phases Hands-on Java exercises with mentor feedback. Good for learning idiomatic
1–3 Java — how real Java developers write code, not just what compiles.
[Link]/design-patterns/ja Phase 3 Every GoF design pattern explained and implemented in Java. Clear, visual
va explanations without videos. Essential for Phase 3 design patterns study.
[Link]/guides Phase 4 Official Spring Boot guides. Short, project-based tutorials covering REST, JPA,
security, and testing. Start here before Spring Boot in Action.
[Link] Phase 2 Use for Java implementation practice. Solve problems in Java to reinforce
onward Collections usage. Full DSA strategy is in the separate Java DSA roadmap.
[Link]/java All phases Reference only. Use to quickly look up Java concepts, syntax examples, and
Collections API behaviour. Not a primary learning source.
[Link] All phases Well-curated Java interview prep articles. Covers Collections internals, thread
safety, JVM, and Spring. Good for checking understanding after each phase.
THE 4 PHASES
PHASE
01 Java Fundamentals & OOP Weeks 1 – 5
Java is a pure object-oriented language — everything lives inside a class. This phase builds the mental model: how the JVM runs
your code, how objects live on the heap while references live on the stack, and how Java's OOP model differs from C++ (no multiple
inheritance of classes, interfaces instead, no pointers — everything is a reference).
~8 – 10 hrs/week recommended
TOPICS COVERED RESOURCES (in order)
■ JVM, JDK, JRE — what each is and how they relate ■ ProgramizPro Java — complete first for syntax overview
■ Primitive types vs reference types — stack vs heap distinction ■ Core Java Vol. I (Horstmann) — Ch. 1–6, 9–10 (primary, do
■ Strings: String, StringBuilder, StringBuffer — immutability all exercises)
explained ■ [Link]/javase/tutorial — OOP and Language
■ Arrays: 1D, 2D, varargs, Arrays utility class Basics trail
■ OOP: classes, objects, constructors, this keyword, method ■ [Link] — search any topic for a second explanation
overloading when needed
■ Access modifiers: public, private, protected, package-private
■ static, final, instanceof — what each means and when to use it
■ Inheritance: extends, super, method overriding, @Override
annotation
■ Interfaces: implements, default methods, functional interfaces
■ Abstract classes: abstract methods, when to use abstract vs
interface
■ Polymorphism: upcasting, downcasting, runtime dispatch
■ Packages, imports, classpath basics
MILESTONE PROJECT
Library Management System (CLI)
MILESTONE — Phase 1 Exit Requirement
■ Abstract class: LibraryItem with title, author, ID, isAvailable — abstract method getInfo()
■ Subclasses: Book, Magazine, DVD — each overrides getInfo(), adds its own fields
■ Library class: manages ArrayList — add, remove, search by title/author/ID
■ Member class: has a name, ID, and a list of currently borrowed items
■ Features: borrow item (checks availability), return item, view all items, view member history
■ All interactions through a console menu loop — clean input handling, no crashes on bad input
■ Pushed to GitHub: java-library-management/ with README and sample output screenshot
PHASE
02 Core Java — Collections, Exceptions & I/O Weeks 6 – 11
The Java Collections Framework is the most important part of the language for interviews and daily work. You will use HashMap,
ArrayList, and PriorityQueue in almost every problem you ever solve. This phase also covers the two other pillars of real-world Java:
exception handling and file I/O.
~10 – 12 hrs/week recommended
TOPICS COVERED RESOURCES (in order)
■ Exceptions: checked vs unchecked, try-catch-finally, throws, ■ Core Java Vol. I (Horstmann) — Ch. 7, 8, 11–13
throw (exceptions, generics, collections, I/O)
■ Custom exceptions: extending Exception and ■ Effective Java (Bloch) — Items 10–20 (equals, hashCode,
RuntimeException Comparable, generics)
■ Multi-catch blocks, try-with-resources (AutoCloseable) ■ [Link]/javase/tutorial — Collections trail and I/O
■ Collections Framework: List, Set, Map, Queue — interfaces trail
and their contracts ■ [Link] — search 'Java HashMap internal working',
■ ArrayList vs LinkedList — when each is faster and why 'Java exceptions best practices'
■ HashMap vs TreeMap vs LinkedHashMap — internal ■ [Link]/tracks/java — work through all available
structure, time complexity exercises from this phase
■ HashSet vs TreeSet vs LinkedHashSet
■ PriorityQueue — min-heap by default, custom comparator for
max-heap
■ Deque and ArrayDeque — use as both stack and queue
■ Generics: type parameters, wildcards (? extends T, ? super T),
bounded types
■ Comparable vs Comparator — natural ordering vs custom
ordering
■ File I/O: FileReader, FileWriter, BufferedReader,
BufferedWriter, Scanner
■ NIO: Path, Files, Paths — the modern Java I/O API
■ Serialisation: Serializable interface, ObjectInputStream,
ObjectOutputStream
MILESTONE PROJECT
Student Grade Management System
MILESTONE — Phase 2 Exit Requirement | LinkedIn-Worthy
■ Student class: name, ID, Map> subjects-to-grades, custom exceptions for invalid grade input
■ GradeBook class: manages HashMap — full CRUD with exception handling
■ Analytics: top student per subject, class average, grade distribution, pass/fail per student
■ Sorting: sort students by GPA using Comparator, by name using Comparable
■ Persistence: save/load entire GradeBook to/from a CSV file using BufferedReader/Writer
■ Reports: generate a formatted text report per student and per class to a .txt file
■ Try-with-resources on all file operations — no resource leaks
■ Pushed to GitHub: java-grade-management/ — README includes architecture, how to run, and sample output
PHASE Advanced Java — Lambdas, Streams, Concurrency Months 3 – 4
03
& Patterns
Modern Java (Java 8 onward) is a different language from what many tutorials teach. The Stream API and lambda expressions
changed how Java code is written in production. Concurrency is the other half — every backend system uses threads and you will
be asked about it in FAANG interviews.
~12 – 15 hrs/week recommended
TOPICS COVERED RESOURCES (in order)
■ Functional interfaces: Predicate, Function, Consumer, ■ Core Java Vol. II (Horstmann) — Ch. 1–6 (streams, I/O,
Supplier, BiFunction concurrency) — primary
■ Lambda expressions: syntax, method references (::), when to ■ Java Concurrency in Practice (Goetz) — read Ch. 1–7,
use each form 10–11 for interview-level depth
■ Stream API: stream(), filter(), map(), flatMap(), reduce(), ■ Effective Java (Bloch) — Items 42–56 (lambdas, streams,
collect() optional)
■ Collectors: toList(), toMap(), groupingBy(), partitioningBy(), ■ Clean Code (Martin) — read alongside project work to
joining() improve design
■ Optional: orElse, orElseGet, orElseThrow, map, filter, ifPresent ■ [Link]/design-patterns/java — all GoF patterns
■ Multithreading: Thread class, Runnable, Callable, with Java implementations
synchronized blocks and methods ■ [Link] — search 'Java Stream API',
■ volatile keyword and the Java Memory Model 'CompletableFuture tutorial', 'Java thread pool'
■ [Link]: ExecutorService, Executors, Future,
CompletableFuture
■ Locks: ReentrantLock, ReadWriteLock, StampedLock
■ Thread-safe collections: ConcurrentHashMap,
CopyOnWriteArrayList, BlockingQueue
■ Design patterns: Singleton (double-checked locking), Factory,
Builder, Observer, Strategy
■ Reflection: Class, getDeclaredMethods, Field access — basics
only
■ Enums, records (Java 16+), sealed classes (Java 17+)
MILESTONE PROJECT
Multi-Threaded File Search & Indexing Engine
MILESTONE — Phase 3 Exit Requirement | LinkedIn-Worthy
■ Recursively scans a directory tree using multiple threads via ExecutorService (configurable thread count)
■ Indexes every word in every .txt/.java/.md file into a ConcurrentHashMap>
■ Search API: given a keyword, returns all file paths and line numbers containing it — in under 100ms on 10k files
■ Stream API used throughout: filtering files by extension, mapping results, sorting by relevance
■ Producer-consumer pattern: scanner threads produce File tasks, indexer threads consume via BlockingQueue
■ Progress reporting: prints indexed file count every second using ScheduledExecutorService
■ CLI: search , index , stats (total files, total words, index size)
■ Pushed to GitHub: java-file-indexer/ — README includes architecture diagram and benchmark results
PHASE
04 Ecosystem & FAANG Capstone Projects Months 5 – 6+
Spring Boot is the industry standard for Java backend development. Every serious Java job expects it. This phase covers the full
ecosystem: Maven/Gradle, Spring Boot REST, Spring Data JPA with PostgreSQL, unit testing, and three FAANG-level projects that
go on your resume.
~15 – 20 hrs/week recommended
TOPICS COVERED RESOURCES (in order)
■ Build tools: Maven ([Link], dependencies, lifecycle) and ■ Spring Boot in Action (Walls) — primary for all Spring Boot
Gradle basics concepts
■ Spring Boot: auto-configuration, @SpringBootApplication, ■ [Link]/guides — official guides: Building a REST service,
[Link] Accessing data with JPA
■ REST: @RestController, @GetMapping, @PostMapping, ■ [Link] — search any Spring Boot topic; every article
@RequestBody, @PathVariable is production-quality
■ Layered architecture: Controller → Service → Repository ■ [Link]/spring-boot/docs/current/reference/html —
pattern official reference docs
■ Spring Data JPA: @Entity, @Repository, JpaRepository, ■ Effective Java (Bloch) — revisit Items on dependency
JPQL, @Query injection, immutability
■ PostgreSQL integration: datasource config, schema creation,
migrations with Flyway
■ Exception handling in Spring: @ControllerAdvice,
@ExceptionHandler, custom error responses
■ DTOs and MapStruct for mapping between entities and
response objects
■ Validation: @Valid, @NotNull, @Size, @Email — Bean
Validation API
■ Unit testing: JUnit 5 (@Test, @BeforeEach, assertions),
Mockito (mock, verify, when/thenReturn)
■ Integration testing: @SpringBootTest, MockMvc,
@WebMvcTest
■ JWT authentication basics with Spring Security
■ Docker: Dockerfile for a Spring Boot app, docker-compose
with PostgreSQL
MILESTONE PROJECT
Three FAANG-Level Capstone Projects — Build All Three
CAPSTONE — FAANG / LINKEDIN LEVEL — Build all 3
■ PROJECT A — Task Management REST API: Spring Boot + PostgreSQL + JWT auth; full CRUD for tasks and users;
tasks have priority, due date, status; filtering + pagination; JUnit + Mockito test suite (80%+ coverage); Dockerfile +
docker-compose; Swagger/OpenAPI docs
■ PROJECT B — Concurrent Chat Server: Java sockets + ExecutorService; supports 100+ simultaneous clients; chat rooms
with join/leave; message history stored in ConcurrentHashMap; admin commands (kick, broadcast); a simple Java Swing
or CLI client
■ PROJECT C — Rate Limiter Library: a reusable Java library implementing token bucket and sliding window algorithms;
thread-safe using ReentrantLock; configurable per-client limits; tested with concurrent JUnit 5 tests simulating burst traffic;
published as a Maven JAR
■ All three in separate GitHub repos: java-task-api/, java-chat-server/, java-rate-limiter/
■ Each README: what it does, architecture, how to build and run, API documentation, test coverage badge
■ Pin all three on GitHub profile — these are resume features
JAVA ECOSYSTEM — TOOLS & WHAT THEY DO
Tool Category What it is and when to use it
JDK / JVM Core Java Development Kit — the compiler (javac) and runtime (JVM). Install JDK 17 LTS or
21 LTS.
IntelliJ IDEA CE IDE Best Java IDE. Community Edition is free. Use this over VS Code for Java — the
refactoring tools and debugger are far superior.
Maven Build tool Manages dependencies ([Link]), builds JARs, runs tests. Learn this in Phase 4. Most
Spring Boot projects use Maven.
Gradle Build tool Faster and more flexible than Maven. Groovy/Kotlin DSL. Know the basics — some
companies use Gradle.
Spring Boot Framework The industry-standard Java web framework. Auto-configures everything. Phase 4
primary focus.
Spring Data JPA ORM Maps Java objects to database tables. Built on Hibernate. Used with Spring Boot for all
database work.
PostgreSQL Database Your preferred DB — already used in your internship. Spring Boot + Spring Data JPA +
PostgreSQL is the standard stack.
JUnit 5 Testing Java's standard unit testing framework. Every project from Phase 2 onward should have
tests.
Mockito Testing Mocking library. Use it to test classes in isolation without needing a real database or
external service.
Docker Deployment Containerise your Spring Boot app. Employers expect you to know basic Docker. Phase
4.
Git + GitHub Version ctrl Use the same Git workflow from the C roadmap. Java-specific .gitignore: exclude /target,
*.class, .idea/
Flyway DB migrations Manages database schema changes through versioned SQL scripts. Used with Spring
Boot + JPA.
KEY DIFFERENCES FROM C (important mental model shifts)
In C: In Java:
■ Manual memory management — malloc/free ■ Garbage Collector manages memory — no free()
■ Segfaults and memory leaks are your problem ■ NullPointerException instead of segfault
■ Pointers — direct memory addresses ■ References — not pointers, no arithmetic
■ No built-in OOP — structs only ■ Everything is a class — pure OOP
■ Single inheritance via function pointers (manually) ■ Single class inheritance, multiple interface implementation
■ Compiled directly to machine code ■ Compiled to bytecode, run by the JVM on any OS
■ int main() is your entry point ■ public static void main(String[] args) always
The biggest mental shift: you cannot control memory directly in Java. The GC runs when it wants. This means you need to
understand object lifecycle (strong/weak references, when objects become eligible for GC) not to manage it, but to avoid memory
leaks through accidentally holding references (e.g. static collections that never get cleared).
JAVA-SPECIFIC INTERVIEW TOPICS (FAANG commonly asks these)
Language internals: Concurrency:
■ How HashMap works internally (hash, bucket, load factor, ■ volatile vs synchronized — what each guarantees
resize) ■ Deadlock — conditions, example, how to prevent
■ equals() and hashCode() contract — why both must be ■ ThreadLocal — what it is and when to use it
overridden together
■ CompletableFuture vs Future — differences and
■ String pool and String interning composition
■ final vs finally vs finalize — what each does ■ ConcurrentHashMap vs [Link]
■ static vs instance — memory and access implications
OOP design:
■ Checked vs unchecked exceptions — design philosophy
■ SOLID principles — name and explain each with a Java
■ Generics type erasure — why List is illegal example
■ Composition over inheritance — when and why
■ Immutable classes — how to write one correctly
WEEKLY HOURS ESTIMATE (for combined schedule)
Phase Timeline Hrs/wk Focus
Phase 1 — Fundamentals & OOP Weeks 1–5 8–10 ProgramizPro + Horstmann Vol. I Ch. 1–10 + Library project
Phase 2 — Collections, Weeks 6–11 10–12 Horstmann Vol. I Ch. 7–13 + Effective Java + Grade project
Exceptions, I/O
Phase 3 — Lambdas, Streams, Months 3–4 12–15 Horstmann Vol. II + Concurrency in Practice + File Indexer
Concurrency
Phase 4 — Ecosystem & FAANG Months 5–6+ 15–20 Spring Boot in Action + three capstone projects
Projects
Java DSA runs simultaneously — expect an additional 8–12 hrs/week for LeetCode, GFG POTD, and the DSA roadmap. See the Java
DSA roadmap for the full breakdown.
JAVA .GITIGNORE — USE IN EVERY PROJECT
# Compiled class files
*.class
# Build output
/target/
/build/
# IDE files
.idea/
*.iml
.vscode/
# Maven wrapper
.mvn/
# OS junk
.DS_Store
[Link]
# Environment
.env
[Link]
Java Roadmap | Jay's Learning Plan | Primary Language | ProgramizPro → Horstmann → Effective Java → Concurrency → Spring Boot → Build. Test.
Push.