What’s New in Java 25

Java 25, released in September 2025, is a Long-Term Support (LTS) version. It includes many language improvements, performance tweaks, and API additions. Some features are stable, some are preview/incubator.

Here are some of the major changes:

Compact source files & instance main methods (JEP 512)
You can now write simpler Java programs without declaring a class explicitly just to define main. Also, you can use void main() without static / public etc, in “compact” source files.
Flexible constructor bodies (JEP 513 – Final)
Earlier, Java required super(...) or this(...) to be the very first statement in a constructor. Now you can write code (validation, computing, etc.) before calling super(...). This helps avoid redundancy or awkward helper methods.
Primitive types in patterns (instanceof, switch) – JEP 507 (Preview)
Pattern matching has become more powerful: primitive types can be “matched” in instanceof or switch.
Module import declarations – JEP 511 (Preview)
You can now import modules via import module, which helps modular projects and reduces boilerplate when referencing multiple types from the same module.
Scoped values (JEP 506 – Final)
A lightweight alternative to ThreadLocal for sharing immutable data across threads (especially with virtual threads).
Performance Improvements & JVM Enhancements
- Compact Object Headers: shrink object header memory footprint.
- Generational Shenandoah GC is now productive (more mature/usable) mode.
- Ahead-of-Time (AOT) method profiling & improved command-line ergonomics.
- More enhancements in Java Flight Recorder (JFR): CPU time profiling, method timing/tracing, cooperative sampling.
Removed / Deprecated Features
- 32-bit x86 port removed.
- Some APIs deprecated; see release notes for full list. Oracle

To make this concrete, here are code snippets showing some of the new features in Java 25.

1. Compact Source File & Instance Main Method

In older Java you would write:


public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Now with compact source file in Java 25:


void main() {
    System.out.println("Hello, World!");
}

You may also omit String[] args if you don’t need command line arguments.

2. Flexible Constructor Bodies

Old restriction: a constructor had to call super(...) or this(...) as the first statement.

New in Java 25:


class Person {
    final int age;
    Person(int age) {
        this.age = age;
    }
}

class Employee extends Person {
    final String name;

    Employee(String name, int age) {
        if (age < 18 || age > 67) {
            throw new IllegalArgumentException("Age must be 18-67");
        }
        super(age);    // no longer the first line; validation occurred before
        this.name = name;
    }

    public static void main(String[] args) {
        Employee e = new Employee("Alice", 35);
        System.out.println("Name: " + e.name + ", Age: " + e.age);
    }
}

3. Primitive Types in Patterns (Preview)


static void describe(Object o) {
    if (o instanceof int i) {
        System.out.println("It's an int: " + i);
    } else if (o instanceof double d) {
        System.out.println("A double: " + d);
    } else {
        System.out.println("Other: " + o);
    }
}

Or in switch:


void testNumber(Object o) {
    switch (o) {
        case int i -> System.out.println("int: " + i);
        case double d -> System.out.println("double: " + d);
        default -> System.out.println("something else");
    }
}

These features are still preview, so you need to enable preview mode when compiling and running.

What You Need To Take Care Of

Many features are preview or incubator: to use them you’ll need compiler flags like --enable-preview.
Compatibility: removed 32-bit x86; deprecated APIs may be removed in future. If your application needs to support older/legacy platforms, test carefully.
Some features, like compact source files, have limitations (e.g. default package, tooling support, IDE support) which may affect larger or enterprise codebases.

Why This Matters

Here are a few benefits and scenarios where the new features help:

Faster prototyping, teaching, scripts less boilerplate means students or small utilities can get to “Hello World” faster.
Cleaner code for validation/initialization logic flexible constructors let you avoid helper methods or redundant checks.
Better performance reduced memory use, better GC, quicker startup, improved profiling & observability.
Modular codebases & AI/modern workloads features like primitive types in patterns, scoped values, module import declarations help write cleaner, more expressive code for modern architectures.

Conclusion

Java 25 is a solid release, especially for those coming from Java 21 or earlier. It continues the trend of making Java less verbose in boilerplate, improving performance, and giving developers more expressive tools, while maintaining compatibility and introducing new performance-oriented JVM features.

If you're using Java 21 (or earlier), moving to Java 25 means you’ll benefit from:

simpler syntax for small programs
safer, more flexible constructors
better memory, GC, and startup performance
access to preview features if you’re willing to try and stay up to date