Location>code7788 >text

Java SE 24 new features

Popularity：527 ℃/2025-03-19 17:28:47

Java SE 24 new features

author:Grey

Original address:

Blog Park: Java SE 24 new features

CSDN: New features in Java SE 24

Source code

Source warehouse:Github：java_new_features

Patterns, instanceof, and switch can match more types (second preview)

By allowing the use of primitive types in all pattern contexts to enhance pattern matching, Java 16 introduced the following:instanceofPattern matching has been introduced in Java 21 withswitchpattern matching.

public class PrimitiveTypesTest {
    void main() {
        test1("hello world");
        test2("hello world");
        test1(56);
        test2(56);
        test1(());
        test2(());
    }

    private static void test1(Object obj) {
        if (obj instanceof String s && () >= 5) {
            (());
        } else if (obj instanceof Integer i) {
            (i * i);
        } else {
            (obj);
        }
    }

    private static void test2(Object obj) {
        switch (obj) {
            case String s when () >= 5 -> (());
            case Integer i -> (i * i);
            case null, default -> (obj);
        }
    }
}

JEP 455Two changes were introduced in Java 23:

  • All primitive types can be used in switch expressions and statements, including long, float, double, and boolean.

  • Secondly, we can also use all primitive types in pattern matching, including instanceof and switch.

In both cases, when switching via long, float, double, and boolean types and pattern matching using primitive variables, switch must cover all possible cases, as with all new switch features.

private static void test3(int x) {
    switch (x) {
        case 1, 2, 3 -> ("Low");
        case 4, 5, 6 -> ("Medium");
        case 7, 8, 9 -> ("High");
    }
}

Module import declaration (second preview)

This feature is the first preview on JDK 23. The main function is to simplify the reuse of the module library by simply importing all packages exported by the module, but does not require that the import code itself must be in the module.

Since Java 1.0,All classes in the package are automatically imported into each .java file. This is why we can use it without importing statementsObject、String、Integer、Exception、Threadetc.

We can also import the complete package. For example, import.*Meaning we don't have to import separatelyList、Set、Map、ArrayList、HashSetandHashMapetc.

JEP 467Now we are allowed to import the full module, or more precisely, all classes in the package exported by the module.

For example, we can import the completemodule, then use the class in that module (e.g.List、Map、Collectors、Stream), without further import:

package .jdk23;

import module ;

public class ModuleImportDeclarationsTest {
    void main() {
        (groupByFirstLetter("a", "abc", "bcd", "ddd", "dddc", "dfc", "bc"));
    }

    public static Map<Character, List<String>> groupByFirstLetter(String... values) {
        return (values).collect((s -> ((0))));
    }
}

If there are two import classes with the same name, such as Date in the following example, the compiler will have an error:

import module ;
import module ;

If one import module temporarily imports another module, we can also use the temporary import module to export all classes in the package without explicit import.

For example, module escapes imports modules:

module  {
  . . .
  requires transitive ;
  . . .
}

Therefore, in the following example, we do not need to explicitly import the SAXParserFactory and SAXParser, nor do we need to explicitly import the module:

SAXParserFactory factory = ();
SAXParser saxParser = ();

Flexible constructor body (third preview)

This function is the second preview on JDK 23, and now it is the third preview. In the following code, the constructor of Child1 can only construct the parent class through super before initializing the variable b of the subclass.

public class FlexibleConstructorBodies {
     void main() {
         new Child1(1, 2);
     }
 }


 class Parent {
     private final int a;

     public Parent(int a) {
          = a;
         printMe();
     }

     void printMe() {
         ("a = " + a);
     }
 }

 // Before JDK 23
 class Child1 extends Parent {
     private final int b;

     public Child1(int a, int b) {
         super(verifyParamsAndReturnA(a, b));
          = b;
     }

     @Override
     void printMe() {
         ();
         ("b = " + b);
     }

     private static int verifyParamsAndReturnA(int a, int b) {
         if (a < 0 || b < 0) throw new IllegalArgumentException();
         return a;
     }
 }

When we execute

new Child1(1,2);

When we were looking forward to returning this code, what we were looking forward to is

a = 1
b = 2

However, because the parent class is called during constructionprintMe(), and this call is called before the initialization of the b variable, so the result of the program execution is

a = 1
b = 0

In the future, before calling the parent class constructor with super(...) and before calling the constructor of this class with this(...) we can execute any code that does not access the current constructor (i.e., does not access its fields),

In addition, we can also initialize the fields of the instance being constructed. See detailsJEP 482

On JDK 24, the above code can be adjusted to:

class Child2 extends Parent {
    private final int b;

    public Child2(int a, int b) {
        if (a < 0 || b < 0) throw new IllegalArgumentException(); 
         = b;                                                
        super(a);
    }

    @Override
    void printMe() {
        ();
        ("b = " + b);
    }
}

In the constructor, the initialization and judgment of a and b can be before the super(...) function call.
implement

new Child2(1,2);

Print result as expected

a = 1
b = 2

The simplified writing method of main method (fourth preview)

First appeared in JDK 21, seeJava SE 21 new features

It turns out that we wrote a main method, we need

public class UnnamedClassesAndInstanceMainMethodsTest {

    public static void main(String[] args) {
        ("Hello World!");
    }

}

Moreover, the name of the Java file needs to be consistent with UnnamedClassesAndInstanceMainMethodsTest. In JDK 24, the above code can be simplified into

void main() {
    ("hello world");
}

Even public class... this paragraph does not need to be written. In JDK 24 version, this function is the fourth preview.

Structured concurrency (fourth preview)

JEP 499 introducedStructured concurrency(Structured Concurrency), which ensures related tasksStart and manage together, make concurrent programming moreSafety,EvenEasy to understand。

Let's understand it with a simple example:Get user data and order data in parallel, and compareTraditional wayandStructured concurrencyHow to implement it.

Traditional way (no structured concurrency)

In traditional methods, we useExecutorServiceAnd manually manage task execution and cancellation:

import .*;

 public class TraditionalConcurrencyExample {
     private static final ExecutorService executor = (2);

     public static void main(String[] args) throws ExecutionException, InterruptedException {
         Future<String> userFuture = (() -> fetchUserData());
         Future<String> orderFuture = (() -> fetchOrderData());

         try {
             String userData = (); // Block until user data returns
             String orderData = (); // Block until the order data returns
             ("User: " + userData + ", Order: " + orderData);
         } finally {
             ();
         }
     }

     static String fetchUserData() {
         try { (1000); } catch (InterruptedException e) { ().interrupt(); }
         return "user data";
     }

     static String fetchOrderData() {
         try { (1000); } catch (InterruptedException e) { ().interrupt(); }
         return "order data";
     }
 }

Existing problems:
Subtask management is complex——Without a clear father-son relationship, it is difficult to control the life cycle of the task.

Manual exception handling——You need to manage the behavior when the task fails.

Resource leakage risk——If one task fails, the other task may still be running, which may lead to an inconsistent state.

Using structured concurrency

Now, we useStructuredTaskScopeLet the task beSame scopeand make sure they areEither finish together or fail together：

import .*;
 import ;

 public class StructuredConcurrencyExample {
     public static void main(String[] args) throws InterruptedException, ExecutionException {
         try (var scope = new ()) {
             <String> userTask = (() -> fetchUserData());
             <String> orderTask = (() -> fetchOrderData());

             (); // Wait for all tasks to complete
             (); // If any task fails, cancel all tasks and throw an exception

             String userData = ();
             String orderData = ();
             ("User: " + userData + ", Order: " + orderData);
         }
     }

     static String fetchUserData() {
         try { (1000); } catch (InterruptedException e) { ().interrupt(); }
         return "user data";
     }

     static String fetchOrderData() {
         try { (1000); } catch (InterruptedException e) { ().interrupt(); }
         return "order data";
     }
 }

The advantages of structured concurrency are as follows:

Task management is clearer——All tasks are onStructuredTaskScopeWithin scope, the code is moreEasy to read。
Automatic cleaning--ifAny task fails, all tasks will be cancelled, there will be no partial completion.
Better error handling——Exception can be()Unified management to avoid manual try-catch.
Easier to debug——All tasks haveA clear parent scope, convenient for troubleshooting.

Structured Concurrency allows parallel tasks to be executedSafer and easier to maintain. It ensures the task orCompleted successfully together, orCancel together failed, avoiding various problems in traditional concurrent programming, such asMission leaks and abnormal propagation difficultieswait.

More

New features have been added to Java SE 7 and later versions, and are being updated continuously...

References

Java Language Changes for Java SE 24

JDK 24 Release Notes

JAVA 24 FEATURES(WITH EXAMPLES

<Previous