Learn Java

Install a JDK, then compile with javac and run with java — or launch a single source file directly.

Classes, the main method, statements, comments and printing output — what every line of Hello World means.

Declare variables, pick among the eight primitive types, write literals and use var for local type inference.

Arithmetic, integer division, increment, comparison, logical and ternary operators, plus casting between numeric types.

Work with immutable Strings: compare with equals, use common methods, build text with StringBuilder and text blocks.

Branch with if/else and with modern switch expressions that return a value and never fall through.

Repeat work with for, while, do-while and the enhanced for-each loop, and control it with break and continue.

Create fixed-size arrays, index into them, loop over them and use java.util.Arrays helpers to print, sort and copy.

Define static methods with parameters and return values, overload them, and understand that Java always passes by value.

Integer, Double and friends wrap primitives as objects; learn autoboxing, parsing text to numbers and the null and == traps.

Read user input with Scanner or BufferedReader and print neatly with printf and format specifiers.

Define a class with fields and instance methods, create objects with new, and understand references, this and null.

Initialise objects with constructors, overload them, chain with this(...), and validate arguments up front.

Hide state behind private fields, expose behaviour through methods, and choose between public, protected, package-private and private.

Extend classes, override methods, call super, and let polymorphism pick the right method at runtime.

Define contracts with interfaces, implement several at once, and use default and static methods.

Model fixed sets of constants with enums that can carry fields, constructors and methods, and switch over them.

Declare immutable data carriers in one line; records generate the constructor, accessors, equals, hashCode and toString.

Model closed hierarchies with sealed interfaces and records, then destructure them with instanceof and switch patterns.

Throw and catch exceptions, understand checked vs unchecked, and clean up resources with try-with-resources.

Read and write files with Path and Files, stream large files line by line, walk directories, and handle charsets correctly.

Use type parameters like List<String> and Map<K, V>, write simple generic classes and methods, and let the diamond infer types.

Use List, ArrayList and List.of, iterate and sort them, and know when to pick which list implementation.

Store key-value pairs in HashMap, unique items in HashSet, and implement equals and hashCode correctly for your keys.

Use bounded wildcards with the PECS rule, understand invariance and type erasure, and know what generics can't do at runtime.

Pass behaviour as values with lambdas and method references, and use the standard functional interfaces in java.util.function.

Process collections declaratively with filter, map, sorted, collect, groupingBy and friends.

Return Optional for values that may be absent and handle them with map, orElse, orElseThrow and ifPresent.

Organise code into packages, understand the classpath and JARs, and build projects with Maven or Gradle.

Write and run JUnit 5 tests with assertions, assertThrows, lifecycle hooks and parameterized tests.

Start threads, recognise race conditions, and fix them with synchronized, locks, atomics and concurrent collections.

Submit tasks to an ExecutorService, collect results with Future, and shut pools down correctly.

Compose asynchronous steps with thenApply, thenCompose, thenCombine, allOf and exceptionally instead of blocking on futures.

Use Java 21 virtual threads to run huge numbers of blocking tasks cheaply, and know their pitfalls: pinning, pooling and ThreadLocals.

Declare and read custom annotations, inspect and invoke code at runtime with reflection, and know the costs.

Describe modules with module-info.java: requires, exports, opens and transitive, and build small runtimes with jlink.

Understand visibility, reordering and the happens-before rules that make volatile, synchronized and final fields work.

How the JVM reclaims memory: reachability, generations, G1, ZGC and Parallel collectors, heap sizing and memory leaks.

Read the JVM's stack-based bytecode with javap, and see how method calls, lambdas and string concatenation really compile.

Follow a class through loading, linking and initialization; understand the loader hierarchy, delegation and NoClassDefFoundError.

How HotSpot interprets, profiles and compiles hot code with C1 and C2: inlining, escape analysis, deoptimization and warm-up.

Find real bottlenecks with JFR, JDK Mission Control, jcmd and JMH, and fix the usual suspects: allocation, locks, I/O and GC.