Learning track 01
Core Java, start to expert
Eleven modules that build on each other, from how the JVM runs your first class to virtual threads in Java 21. Read them in order and nothing later will feel like magic.
- Articles
- 55
- Modules
- 11
- Total read
- 10 hr 34 min
- Streak
- 0 days
Start here
How Java Runs Anywhere
01
Java Platform & Execution
What actually happens between writing code and seeing output
0/4
- How Java Runs AnywhereBytecode, the compile-run cycle, and why one build artefact works on every operating system.
- JVM, JRE and JDKThree names people use interchangeably, what each one actually contains, and which you need when.
- Inside the JVMClass loading, the runtime data areas, and how the interpreter and JIT compiler split the work.
- Anatomy of a Java Programmain(), packages, access modifiers, static blocks, and the order in which everything initialises.
02
Language Fundamentals
Types, control flow, methods and the memory model behind them
0/5
- Types, Variables and WrappersPrimitives and their defaults, autoboxing traps, enums, and the operators worth a second look.
- Control Flow and ArraysLoops, switch, and arrays — including jagged arrays and the copying method that actually works.
- Methods and ConstructorsOverloading rules, constructor chaining, covariant returns, and why reflection needs a different call.
- Java Is Always Pass-by-ValueThe single rule that explains why a method can mutate your object but never reassign your variable.
- Reading and Writing DataByte streams versus character streams, why buffering matters, and how to take console input.
03
Object-Oriented Programming
The four pillars, plus the design judgement that uses them well
0/7
- Why ObjectsClasses versus objects, the four pillars at a glance, and the problem object orientation solves.
- Encapsulation and AbstractionTwo ideas that are constantly confused: hiding data versus hiding complexity.
- Inheritance and Compositionextends, super and this — plus the judgement call about when not to inherit at all.
- PolymorphismOverloading resolves at compile time, overriding at run time — and method hiding fools everyone once.
- Interfaces and Abstract ClassesHow to choose between them, how default methods changed the answer, and what annotations add.
- Nested Classes and Immutable ObjectsFour kinds of nested class, and the recipe for an object nobody can modify after construction.
- SOLID in PracticeFive principles as five questions to ask about a class, with the refactor each one suggests.
04
Strings, Objects & Equality
String handling and the contracts every object inherits
0/4
- Strings, Builders and the PoolWhy String is immutable, what the pool actually stores, and when to reach for StringBuilder.
- equals, hashCode and the Object ContractThe contract that makes HashMap work, and exactly what breaks when you implement only half of it.
- Shallow and Deep CopiesWhat clone() really does, why it surprises people, and safer ways to copy an object.
- SerializationTurning objects into bytes, the role of serialVersionUID and transient, and the security caveat.
05
Exception Handling
Failing safely, and knowing which failures you should not catch
0/3
- The Exception HierarchyChecked versus unchecked, Error versus Exception, and which branch you should never catch.
- try, catch, finally and ResourcesMulti-catch, try-with-resources, propagation, and the edge cases where finally surprises you.
- Designing for FailureCustom exceptions, what to log, the final/finally/finalize confusion, and anti-patterns to drop.
06
Generics & Collections
Type safety first, then every data structure and its real cost
0/10
- Generics and Type SafetyType parameters, bounds, wildcards and erasure — the foundation every collection is built on.
- The Collections FrameworkHow List, Set, Queue and Map relate, and how to pick one from the shape of your problem.
- ArrayList and LinkedListHow each one stores elements, what that costs per operation, and which to default to.
- HashSet, LinkedHashSet and TreeSetThree ways to guarantee uniqueness, differing only in ordering, cost and null handling.
- Working with MapsKey-value basics, the modern convenience methods, and what load factor means for your code.
- How HashMap Works InsideBuckets, collision chains, treeification and resizing — the most asked internals question there is.
- Ordered and Sorted MapsLinkedHashMap for insertion order and LRU caches, TreeMap for sorted keys and range queries.
- Queues, Deques and Priority QueuesEnds-first data structures, why ArrayDeque replaced Stack, and how a priority queue really orders.
- Iteration and OrderingFail-fast versus fail-safe, safe removal during a loop, and Comparable versus Comparator.
- Thread-Safe CollectionsWhy synchronizedMap bottlenecks, how ConcurrentHashMap avoids it, and when copy-on-write wins.
07
Memory & JVM Internals
Where objects live, how they are freed, and why leaks still happen
0/4
- Stack and HeapWhich memory region holds your variable, which holds the object, and why that distinction matters.
- JVM Memory RegionsEden, survivor spaces, old generation and metaspace — the layout behind every tuning flag.
- Garbage CollectionReachability, minor and major cycles, the collectors you will meet, and the four reference strengths.
- Finding Memory LeaksThe handful of patterns that cause nearly every Java leak, and how to confirm one from a heap dump.
08
Multithreading & Concurrency
Shared state, locks, pools and coordination between threads
0/5
- Threads and Their LifecycleCreating threads three ways, the six states, and what daemon threads change about shutdown.
- Thread SafetyRace conditions, what synchronized and volatile each guarantee, and where ThreadLocal fits.
- Locks and Thread PoolsReentrantLock over synchronized, read-write locks, and sizing an executor properly.
- Coordinating Threadswait and notify done correctly, blocking queues, and the latch, barrier and semaphore trio.
- Callable, Future and Fork/JoinReturning values from tasks, where Future falls short, and how fork/join splits big work.
09
Java 8 Modern Features
Lambdas, streams and asynchronous composition
0/4
- Lambdas and Functional InterfacesBehaviour as a parameter, the built-in functional interfaces, and the four method reference forms.
- The Stream APILazy pipelines, the collectors worth memorising, and an honest look at parallel streams.
- Optional and the Date-Time APIModelling absence without null, and the immutable date types that replaced Date and Calendar.
- CompletableFutureComposing asynchronous work without blocking, combining results, and handling failure in the chain.
10
Java 17 LTS
Records, sealed types, pattern matching and the platform catch-up
0/5
- RecordsImmutable data carriers in one line, with validation in a compact constructor when you need it.
- Sealed ClassesClosing a hierarchy on purpose, so the compiler can prove you handled every case.
- Pattern Matching for instanceofTest, cast and bind in one step — and the guarded patterns that remove nested conditionals.
- Switch Expressions and Text BlocksSwitch that returns a value with no fall-through, plus multi-line strings that stay readable.
- From Java 8 to 17The Java 11 features you use daily, modules, helpful null messages, and what was removed.
11
Java 21 LTS
Virtual threads, full pattern matching and sequenced collections
0/4
- Virtual ThreadsMillions of concurrent tasks on a handful of carrier threads, and the pinning trap to avoid.
- Pattern Matching for switchRecord patterns, destructuring and exhaustiveness — data-oriented programming in practice.
- Sequenced CollectionsOne vocabulary for first, last and reversed across every ordered collection.
- Java 21 and What Comes NextGenerational ZGC, the preview features worth watching, and a practical 8 to 21 migration path.