{"id":604053,"date":"2025-09-16T12:15:34","date_gmt":"2025-09-16T11:15:34","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=idea&p=604053"},"modified":"2025-09-26T13:34:23","modified_gmt":"2025-09-26T12:34:23","slug":"java-25-lts-and-intellij-idea","status":"publish","type":"idea","link":"https:\/\/blog.jetbrains.com\/zh-hans\/idea\/2025\/09\/java-25-lts-and-intellij-idea","title":{"rendered":"Java 25 LTS and IntelliJ IDEA"},"content":{"rendered":"\n

The Java release cadence means we get a new Java version every six months. Java 25 was released on September 16, 2025. At JetBrains, we are committed to supporting new technologies in IntelliJ IDEA and adding useful enhancements for both stable and preview features. In this blog post, we will give you an overview of some changes to the Java language and how they are supported in IntelliJ IDEA. This post is limited to stable features only. Preview features will be covered separately in dedicated blog posts on relevant topics.<\/p>\n\n\n\n

Java 25<\/a> includes several changes to the language that make Java easier to use. Features like compact source files and instance main methods<\/a>, as well as module import declarations<\/a>, make it easier to get started with Java, both for students and when creating small projects like prototypes or hobby projects. Flexible constructor bodies<\/a> allow more flexibility in constructors, giving you the option to calculate or validate data before calling the constructor of the super class. Scoped values<\/a> are a new model for thread-local variables, adapted to virtual threads. They will be more useful with structured concurrency<\/a>, which is currently still in preview.<\/p>\n\n\n\n

Apart from changes to the language itself, there are improvements to both performance and performance insights. Compact object headers<\/a> reduce memory footprint and improve cache efficiency. Ahead-of-time method profiling<\/a> lets the JVM warm up more quickly by using execution data from prior runs, improving startup performance. Improvements to garbage collection (GC) like generational Shenandoah<\/a>, plus better class-loading and linking optimizations, contribute to noticeably smoother server-style workloads.<\/p>\n\n\n\n

As Java 25 is an LTS (long-term support) release<\/a>, many people will be migrating to this version from Java 21, 17, 11, or even earlier. If you are coming to Java 25 from Java 21, have a look at the section describing the most relevant changes since Java 21.<\/p>\n\n\n\n

Before diving into the new features, let\u2019s set up IntelliJ IDEA to use Java 25.<\/p>\n\n\n\n

Using Java 25 in IntelliJ IDEA (setup)<\/h1>\n\n\n\n

To use Java 25, you will need to download the JDK. You can do so from inside IntelliJ IDEA or by using tools like SDKMAN! To download a JDK from IntelliJ IDEA, open the Project Structure<\/em>, go to the tab Project Settings | Project<\/em>, open the drop-down menu in the SDK <\/em>field, and select Download JDK<\/em>. <\/p>\n\n\n\n

\"\"
Downloading JDK from inside IntelliJ IDEA<\/em><\/figcaption><\/figure>\n\n\n\n

In the Download JDK<\/em> popup that opens, set Version<\/em> to 25<\/em>, <\/em>and in the Vendor<\/em> field, select the vendor you want to use. <\/p>\n\n\n\n

You can also download Early Access (EA) versions of the JDK from inside IntelliJ IDEA, for example, when the next release becomes available or if you\u2019d like to try Valhalla (which is based on Java 23). IntelliJ IDEA will warn you that these are not intended for production use. <\/p>\n\n\n\n

\"\"
Downloading an Early Access version<\/em><\/figcaption><\/figure>\n\n\n\n

Next, you need to configure IntelliJ IDEA to use the right language level. To use Java 25 stable features, which is recommended for production code, set Language level<\/em> to 25 – Compact source files, module imports<\/em>.<\/p>\n\n\n\n

\"\"
Setting <\/em>Language level to <\/em>25<\/figcaption><\/figure>\n\n\n\n

If you want to try out preview features, set Language level<\/em> to 25 (Preview) – Primitive Types in Patterns, etc<\/em>.<\/p>\n\n\n\n

\"\"
Setting <\/em>Language level to <\/em>25 (Preview)<\/figcaption><\/figure>\n\n\n\n

New stable features in Java 25<\/h1>\n\n\n\n

Let\u2019s take a look at some of the features Java 25 introduces and how IntelliJ IDEA can help you use them.<\/p>\n\n\n\n

Compact Source Files and Instance Main Methods (JEP 512)<\/h2>\n\n\n\n

Java has been working on the so-called \u201con-ramp\u201d, making the language easier to use. Compact source files and instance main methods<\/a> are part of that effort. It is now possible for beginners to start writing code without needing to learn about language concepts that they won\u2019t need until they start writing larger programs. For experienced programmers, this feature can help them quickly prototype ideas without needing a lot of boilerplate code. Code can be evolved and expanded as skills and applications grow. <\/p>\n\n\n\n

To quickly see the difference, let\u2019s look at a classic example: HelloWorld<\/code>. We have probably all written a HelloWorld example when we first started, possibly in a language other than Java or English. The classic HelloWorld.java<\/code> looks like this:<\/p>\n\n\n\n

public class HelloWorld {\n\u00a0\u00a0\u00a0public static void main(String[] args) {\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.out.println(\"Hello, World!\");\n\u00a0\u00a0\u00a0}\n}<\/pre>\n\n\n\n
To write this code, you had to declare a class and a lengthy main method, including concepts like public<\/code> and static<\/code> that are not relevant to beginners. Let\u2019s compare this to the HelloWorld<\/code> example using new features from compact source files and instance main methods. <\/p>\n\n\n\n
When creating a new Java class via New | Java Class<\/em>, in the New Java Class<\/em> popup, select the Compact source file <\/em>option. Note that this compact source file is created in the root directory of your project, even if you create it from another package. IntelliJ IDEA automatically adds an instance main method \u2013 void main()<\/code> \u2013 to the file. Next, you can add a method to print \u201cHello, World!\u201d. You can now use IO.println()<\/code> as a convenience method without needing to understand what System.out<\/code> means and without even needing to add a static import. If you do want to add a static import for java.lang.IO<\/code>, IntelliJ IDEA offers a quick-fix to do so.<\/p>\n\n\n\n
Creating `HelloWorld.java`<\/em><\/figcaption><\/figure>\n\n\n\n
Note that different variations of the main method are now possible, as described here<\/a>.<\/p>\n\n\n\n
IntelliJ IDEA has some new live templates<\/a> to add a main method to an implicit class, either with or without arguments: main<\/code>, maina<\/code>, psvm<\/code>, and psvma<\/code>. Using the psvm<\/code> or main<\/code> live templates inside a compact source file will add the new main method, while they will continue to add the classic main method inside a class, as you can see in the preview.<\/p>\n\n\n\n
\"\"
Live templates for the main method in a compact source file<\/em><\/figcaption><\/figure>\n\n\n\n
\"\"
Live templates for the main method in a compact source file<\/em><\/figcaption><\/figure>\n\n\n\n
Our new version of HelloWorld<\/code> now looks like this:<\/p>\n\n\n\n
void main() {\n\u00a0\u00a0\u00a0IO.println(\"Hello, World!\");\n}<\/pre>\n\n\n\n
Compare this code to the original example. It is much shorter, contains less boilerplate, and is limited to only the things we need: a main method and a call to print a line with the provided \u201cHello, World!\u201d String<\/code>.<\/p>\n\n\n\n
As beginners often need to interact with the console, a convenient readln()<\/code> method was also added. This is an overloaded method which can take a String<\/code> argument that is printed to the console before reading the input. Let\u2019s expand our previous example to read a name from the console. To help you use these new convenience methods, IntelliJ IDEA introduces two new live templates: iop<\/code> for println()<\/code> and ior<\/code> for readln()<\/code>.<\/p>\n\n\n\n
Expanding the example to use the convenience method readln()<\/em><\/figcaption><\/figure>\n\n\n\n
Note that these changes to the language are also taken into account when creating new projects. When you create a new Java project, set Build system<\/em> to IntelliJ<\/em>, and select Add sample code<\/em>, a compact source file with a void main()<\/code> method will be added. <\/p>\n\n\n\n
Creating a new project with the IntelliJ build system<\/em><\/figcaption><\/figure>\n\n\n\n
Prototyping and teaching<\/h3>\n\n\n\n
While extremely useful for students and teachers, this feature does not just benefit beginners. It also allows experienced developers to quickly try out ideas or create a prototype. <\/p>\n\n\n\n
When you create a new Java project with Maven or Gradle as the selected build system, the generated source code will include a regular class, but with IO.println()<\/code> instead of System.out.println()<\/code>. If you are using Maven or Gradle, you\u2019re likely working on something bigger, with actual classes instead of compact source files. Another reason to use classes is that a compact source file needs to be in the default package, and frameworks generally don\u2019t support this. <\/p>\n\n\n\n