Java 8 to 21: the must-knows

For this sheet, we'll start with the Java 8 core (functional interfaces, method references, streams, collectors, Optional) because that's where most marks are won or lost. Then we'll move through the features in release order and finish with the LTS summary, the traps, and the talk track. All code compiles and runs on Java 21, and I mark the version each feature arrived in, because "which version added records?" is a real question.

01Picture it first: four LTS releases, ten years

Think of modern Java as four big stops on a train line. Most companies jump from one long-term support (LTS) release to the next and skip the six-monthly releases in between, so interviewers frame questions as "8 vs 11 vs 17 vs 21". The timeline below shows each LTS with its headline features, and the in-between releases where most of the syntax actually landed.

Fig. 1

A timeline from Java 8 in 2014 to Java 25 in 2025 marking the LTS releases 8, 11, 17, 21 and 25 with their headline features, and the non-LTS releases where var, switch expressions, text blocks, records and unnamed variables arrived

• Version note: Java 25 (Sep 2025) is the newest LTS. It finalised scoped values, compact source files and instance main methods (Compact source files), and flexible constructor bodies. Interviews still center on 17 and 21, so this sheet stays on 21.

02Lambdas and functional interfaces

A functional interface is an interface with exactly one abstract method; a lambda is a compact implementation of that one method. @FunctionalInterface is optional, but it makes the compiler reject a second abstract method. Methods inherited from Object (like equals on Comparator) and default methods don't count. Under the hood, javac emits an invokedynamic call and the JVM builds the implementation at runtime through LambdaMetafactory, so unlike anonymous classes there's no Outer$1.class file per lambda.

• Primitive specializations avoid boxing: IntPredicate, ToIntFunction, IntStream and friends work on int directly. Stream<Integer>.map(...) boxes every element; mapToInt(...) doesn't.
• Composition: Predicate.and/or/negate, Function.andThen/compose, Comparator.comparing(...).thenComparing(...).reversed(). Functional interfaces in Java
• Effectively final capture: a lambda can read a local variable only if it's final or never reassigned. The lambda receives a copy of the value, and it may run later or on another thread, so allowing reassignment would make that copy silently stale and racy. Fields aren't restricted, because the lambda captures this, not a copy of the field.
• this inside a lambda is the enclosing instance; inside an anonymous class it's the anonymous object. A lambda also can't redeclare a local variable name from the enclosing scope. Inner, static nested and anonymous classes

int count = 0;
List.of("a", "b").forEach(s -> count++);          // compile error: count is not effectively final

int[] box = {0};
List.of("a", "b").forEach(s -> box[0]++);         // compiles, but it's a smell (and racy in parallel)

long count2 = Stream.of("a", "b").count();        // the right answer: let the stream count

03Method references: the four kinds

A method reference is a lambda whose body only calls one existing method. Interviewers ask for the four kinds because the third one confuses people.

• Unbound references shift the receiver: String::compareTo fits a Comparator<String> (two arguments) because the first argument becomes this. That's why BiFunction<String, String, Boolean> f = String::equals; compiles.
• A bound reference evaluates its receiver once, when the reference is created. foo()::bar calls foo() immediately; x -> foo().bar(x) calls it every time.

04Streams: a lazy pipeline, one element at a time

Interview questions for this topicComing soon