New features of [JAVA 11] (combined with examples)

new features

Java 11 introduces many new features and improvements. Here are some of the major new Java 11 features:

1. Local variable type inferencevar : Java 11 supports the use of keywords in the declaration of local variables for type inference . By omitting the type of a variable, you can declare local variables more concisely and improve the readability of your code.

2. String API enhancements : Java 11 introduces some new methods and features to handle strings. These include isBlank()methods for detecting whether a string is blank, lines()methods for splitting a string into lines, and methods such as strip(), , stripLeading()and stripTrailing(), for removing spaces before and after a string.

3. HTTP client standardization : A standard HTTP client API ( java.net.http) was introduced in Java 11 for sending HTTP requests and processing responses. This new HTTP client provides support for asynchronous and synchronous requests, as well as an easier-to-use API.

4. Garbage collector improvements : Java 11 introduces a new garbage collector (Epsilon GC), which is a no-op (No-Op) garbage collector for use in testing and performance tuning scenarios. Additionally, Java 11 improves existing garbage collectors such as G1 garbage collector and ZGC.

5. Dynamic Class File Constants : Java 11 introduces a new type of constant - Dynamic Class File Constants. It can be used at runtime via invokedynamicdirectives and can be updated without recompiling the code.

6. New standardized HTTP/2 client and server API : The standardized HTTP/2 API introduced in Java 9 has been improved and enhanced. Java 11 provides a more complete HTTP/2 client and server API, making it easier for developers to use and build applications based on the HTTP/2 protocol.

7. Flight Recorder event stream processing : Java 11 opens Flight Recorder's event stream data to developers for real-time processing and analysis. This allows developers to monitor and debug application performance, behavior, and exceptions in greater detail.

8. Removed features : Java 11 has also removed some outdated or no longer recommended features, such as Applet API, JavaFX, Nashorn JavaScript engine, etc.

New feature code examples

This is just an overview of some of the major new features and improvements in Java 11. Java 11 also includes other small improvements and optimizations to improve developer productivity and application performance.

When talking about the new features of Java 11, it is best to explain each feature in more detail with examples. Here are some examples of new Java 11 features and their detailed explanations:

1. Local variable type inference :

In Java 11, varkeywords were introduced that can be used for local variable type inference. By using var, the compiler infers the type of the variable based on the expression on the right-hand side. This makes the code cleaner and improves readability.

// 在Java 11之前
List<String> names = new ArrayList<>();

// 使用局部变量类型推断
var names = new ArrayList<String>();

In the above example, varthe keyword is used to declare an ArrayListobject without explicitly specifying its type List<String>.

2. String API enhancements :

Java 11 has improved the String API, introducing some new methods and features.

String text = "   Hello, World!   ";

// 检测字符串是否为空白
if (text.isBlank()) {
    
    
    System.out.println("The string is blank.");
}

// 删除字符串前后的空格
String trimmedText = text.strip();
System.out.println(trimmedText);  // 输出: "Hello, World!"

// 将字符串拆分成行
text.lines().forEach(System.out::println);

In the example above, we used isBlank()the method to detect if a string is blank, strip()the method to remove spaces before and after the string, and lines()the method to split the string into lines.

3. HTTP client standardization :

Java 11 introduces a new java.net.httppackage that provides a standard set of HTTP client APIs. Here's an example of sending a GET request and processing the response asynchronously:

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/data"))
        .build();

client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body)
        .thenAccept(System.out::println);

In the above example, we create an HttpClientinstance and use it to send an asynchronous GET request. By chaining calls, we can further process the response body.

This is just an example of some of the new features of Java 11, there are other features such as garbage collector improvements, dynamic class file constants, new standardized HTTP/2 client and server API, etc., which also provide corresponding examples and detailed explanations . Using these new features, developers can more easily write modern Java code and improve application performance and readability.

Syntactic sugar

In Java 11, although a lot of syntactic sugar (syntactic sugar) has not been introduced, there are still some small syntactic improvements that make the code more concise and readable. Here are some examples of syntactic sugar in Java 11:

1. Local variable type inference :

Java 11 introduced varkeywords that can be used for local variable type inference. By using var, the compiler infers the type of the variable based on the expression on the right-hand side.

// 在Java 11之前
List<String> names = new ArrayList<>();

// 使用局部变量类型推断
var names = new ArrayList<String>();

2. Lambda parameter type inference :

Prior to Java 11, the parameter types of lambda expressions needed to be explicitly declared. In Java 11, you can omit the parameter type of a Lambda expression, and the compiler will automatically infer the parameter type.

// 在Java 11之前
Function<Integer, String> function = (Integer x) -> String.valueOf(x);

// 使用Lambda参数类型推断
Function<Integer, String> function = (x) -> String.valueOf(x);

3. Extended Lambda parameter names :

Before Java 11, the parameters of Lambda expressions could only use single letters such as x, yand so on as names. In Java 11, you can use underscore _as a wildcard to indicate that the parameter is not used.

// 在Java 11之前，无法省略未使用的参数
Consumer<String> consumer = (String x) -> System.out.println("Hello, " + x);

// 使用扩展Lambda参数名称
Consumer<String> consumer = (_) -> System.out.println("Hello, World!");

4. Syntactic sugar for set operations :

The Stream API was introduced in Java 8 for operating on collections, and Java 11 further added some methods to simplify collection operations.

List<String> names = List.of("Alice", "Bob", "Charlie");

// Java 11之前需要使用collect(Collectors.toList())
List<String> upperCaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

// Java 11中使用toList()方法
List<String> upperCaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .toList();

Above are some examples of syntactic sugar in Java 11. These small syntax improvements make the code more concise and readable, and increase developer productivity. It should be noted that syntactic sugar does not change the underlying semantics of Java, but only provides a more convenient way of writing.