Java 22 to 25 Features

When a school redesigns its first-day welcome for new students, it doesn't change the subjects; it removes the confusing forms and long speeches that scare newcomers away. Several of the changes from Java 22 to Java 25 do exactly that for Java: a first program no longer needs public class and public static void main(String[] args), and a single import line can bring in a whole module. Alongside these friendlier changes came serious power tools: calling C libraries safely, custom stream operations, and faster startup. Java 25 (September 2025) is the LTS that collects them all, and it is the version this course is written for. In this lesson, you will get a quick reference to each release and a tour program that uses the Java 25 features.

What Each Release Added

Java 25 in Detail

Still in preview or incubation in Java 25: structured concurrency, primitive types in patterns, stable values and the Vector API.

A Java 22 to 25 Tour

Let's see a compact source file that uses features from every release in this range. There is no class declaration around main: the file itself is the program.

import module java.base;                                // 25: module import
 
record Fee(String student, int amount) {}
 
class LateFee extends RuntimeException {
    LateFee(int days) {
        String why = "late by " + days + " days";       // 25: before super
        super(why);
    }
}
 
static final ScopedValue<String> TERM = ScopedValue.newInstance();
 
void main() {                                           // 25: compact source
    List<Fee> fees = List.of(new Fee("Navika", 15000),
            new Fee("Srihitha", 14000), new Fee("Advitha", 16000));
 
    int count = 0;
    for (Fee _ : fees) count++;                         // 22: unnamed variable
    IO.println("fees: " + count);
 
    List<List<Fee>> batches = fees.stream()
            .gather(Gatherers.windowFixed(2))           // 24: gatherers
            .toList();
    IO.println("batches: " + batches.size());
 
    ScopedValue.where(TERM, "Term 2")                   // 25: scoped values
            .run(() -> IO.println("billing " + TERM.get()));
 
    try {
        throw new LateFee(3);
    } catch (LateFee e) {
        IO.println(e.getMessage());
    }
}

fees: 3
batches: 2
billing Term 2
late by 3 days

Explanation:

1. import module java.base; makes List, Gatherers and every other java.base class available without separate imports.
2. void main() with no class around it is a compact source file. IO.println is the new, simpler console helper in java.lang.
3. for (Fee _ : fees) says "I don't need the element", so no unused variable is named.
4. Gatherers.windowFixed(2) groups the three fees into batches of two and one.
5. ScopedValue.where(...).run(...) makes TERM readable only while that code runs.
6. The LateFee constructor computes its message before calling super(why), which was a compile error before Java 25.

The LTS Releases at a Glance

Practice

1. Easy: Write a compact source file Hello.java containing only void main() { IO.println("Hello, Navika Anamaneni"); } and run it with java Hello.java.
2. Harder: From memory, write the LTS table above: release, year and three features each. Then check it against this lesson.

Key Takeaways