Fundamentals
Syntax, Types & Control Flow beginner Learn Java's type system — eight primitives (int, long, double, float, boolean, char, byte, short) and their wrapper classes for autoboxing. Strings are immutable — use StringBuilder for concatenation in loops. Master switch expressions (not just statements), enhanced for loops, and var for local variable type inference. Arrays are fixed-size — you'll use collections for everything else.
8h Fundamentals
OOP Fundamentals beginner Java is object-oriented by design. Learn classes, constructors, and the four access modifiers (private, protected, public, package-private). Master encapsulation, inheritance, and polymorphism. Understand abstract classes vs interfaces — interfaces now support default and static methods. Always override equals(), hashCode(), and toString() together.
10h Fundamentals
Collections Framework beginner The Collections Framework is the backbone of Java data handling. Know when to use ArrayList vs LinkedList, HashSet vs TreeSet, HashMap vs TreeMap vs LinkedHashMap. Understand the Collection and Map interfaces and their contracts. Use Collections utility methods for sorting, searching, and wrapping. Implement Comparable and Comparator for custom ordering.
10h Java separates checked exceptions (must handle or declare) from unchecked exceptions (RuntimeException subclasses). Use try-with-resources for any AutoCloseable resource — files, connections, streams. The java.nio.file API (Path, Files) replaces the old File class. Know the difference between byte streams and character streams, and when to buffer.
8h Core
Generics & Type Bounds intermediate Generics provide compile-time type safety without sacrificing reusability. Learn generic classes, methods, and interfaces. Understand bounded type parameters (extends for upper bounds, super for lower bounds) and wildcards (?, ? extends T, ? super T). The PECS principle — Producer Extends, Consumer Super — guides wildcard usage. Type erasure means generics are a compile-time feature only.
10h Core
Functional Interfaces & Streams intermediate Lambda expressions bring functional programming to Java. Learn the core functional interfaces — Predicate, Function, Consumer, Supplier, and BiFunction. The Stream API (map, filter, reduce, collect, flatMap, groupingBy) transforms how you process collections. Use Optional to represent absent values instead of null. Be cautious with parallel streams — they're rarely faster for small datasets.
12h Intermediate
Concurrency & Multithreading intermediate Java has first-class concurrency support. Learn Thread lifecycle, Runnable vs Callable, and why synchronized alone is not enough. Use ExecutorService and thread pools instead of raw threads. CompletableFuture chains async operations elegantly. Concurrent collections (ConcurrentHashMap, CopyOnWriteArrayList) avoid manual locking. Virtual threads from Project Loom make high-concurrency I/O trivial.
14h Advanced
Records, Sealed Classes & Pattern Matching advanced Modern Java is not the verbose language people remember. Records give you immutable data carriers with automatic equals, hashCode, and toString. Sealed classes restrict inheritance hierarchies for domain modeling. Pattern matching for instanceof eliminates casting boilerplate. Switch pattern matching with guards creates expressive, exhaustive handling of complex types.
8h Advanced
Module System & Build Tools advanced The Java Platform Module System (JPMS) brings strong encapsulation to packages — module-info.java declares what you export and what you depend on. Understand requires, exports, opens, and provides/uses for services. Know Maven or Gradle for dependency management, build automation, and multi-module projects. JUnit 5 is the standard for testing.
10h Production
Advanced Patterns & JVM Awareness advanced Understand reflection and annotations — both built-in (@Override, @Deprecated, @FunctionalInterface) and custom. Apply design patterns idiomatically in Java — Builder for complex construction, Strategy with lambdas, Observer with functional interfaces. Know the JVM basics — heap vs stack, garbage collection generations (G1, ZGC), and how to read GC logs. Write code that follows Effective Java principles.
12h 