Java 18 Features

Java 18, released in March 2022, introduces several new features, performance improvements, and deprecations. This guide explores the key features introduced in Java 18, including UTF-8 as the default charset, a simple web server, and code snippets in API documentation. It also covers preview and incubator features, as well as deprecations and other changes.

1. UTF-8 by Default

Java 18 sets UTF-8 as the default charset for the Java platform. This change ensures consistent behavior across different environments and simplifies the handling of text data.

This change simplifies the development process by eliminating the need to explicitly specify UTF-8 as the charset for text-related operations.

Charset.forName() Taking Fallback Default Value

In Java 18, the Charset.forName() method can take a fallback default value, providing more flexibility in charset handling.

Example

import java.nio.charset.Charset;

public class CharsetExample {
    public static void main(String[] args) {
        Charset charset = Charset.forName("UTF-16", Charset.defaultCharset());
        System.out.println("Charset: " + charset.name());
    }
}

Explanation

• Fallback Value: The Charset.forName() method can take a fallback default value, providing more flexibility in handling charsets and ensuring that a valid charset is always used.

2. Simple Web Server

Java 18 introduced a simple web server as part of the JDK, making it easier for developers to run and test web applications without needing to set up a full-featured web server like Apache or Tomcat. This simple web server is suitable for prototyping, testing, and simple applications. 

Key Features 

• Ease of Use: Quick to set up and run. 
• Minimal Configuration: Requires minimal setup and configuration. 
• Static File Serving: Capable of serving static files from a directory. 
• Lightweight: Ideal for lightweight use cases like testing and development.

Example

import com.sun.net.httpserver.HttpServer;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class SimpleWebServer {
    public static void main(String[] args) throws IOException {
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
        server.createContext("/hello", exchange -> {
            String response = "Hello, World!";
            exchange.sendResponseHeaders(200, response.getBytes().length);
            OutputStream os = exchange.getResponseBody();
            os.write(response.getBytes());
            os.close();
        });
        server.start();
        System.out.println("Server started on port 8000");
    }
}

Explanation

• Easy Setup: The simple web server allows developers to easily set up and run HTTP servers for testing and small applications.
• Prototyping: This feature is useful for prototyping and testing web applications without the need for complex server setups.

3. Code Snippets in Java API Documentation

Java 18 enhances the Java API documentation with code snippets, providing more practical examples and improving its usability.

Example

/**
 * This is an example method.
 *
 * <pre>{@code
 * ExampleClass example = new ExampleClass();
 * example.exampleMethod();
 * }</pre>
 */
public void exampleMethod() {
    // Method implementation
}

Explanation

• Practical Examples: Code snippets in the Java API documentation provide practical examples, making it easier for developers to understand how to use different APIs.
• Improved Usability: This feature improves the usability of the documentation, helping developers quickly find and understand relevant examples.

4. Internet-Address Resolution SPI

Java 18 introduces an SPI (Service Provider Interface) for internet address resolution, allowing developers to customize the resolution of internet addresses.

Example

import java.net.spi.InetAddressResolver;
import java.net.spi.InetAddressResolverProvider;

public class CustomInetAddressResolverProvider extends InetAddressResolverProvider {
    @Override
    public InetAddressResolver get(InetAddressResolverProvider.Configuration configuration) {
        return new CustomInetAddressResolver();
    }
}

Explanation

• Customization: The Internet-Address Resolution SPI allows developers to customize the resolution of Internet addresses, providing more control and flexibility.
• Enhancements: This feature enhances the ability to handle internet addresses in Java applications, improving performance and reliability.

5. Preview and Incubator Features

Pattern Matching for switch (Second Preview)

Pattern matching for switch, reintroduced as a preview feature in Java 18, allows switch statements to match patterns, providing more concise and readable code.

Example

public class PatternMatchingSwitchExample {
    public static void main(String[] args) {
        Object obj = "Java 18";
        String result = switch (obj) {
            case Integer i -> "Integer: " + i;
            case String s -> "String: " + s;
            default -> "Unknown type";
        };
        System.out.println(result);
    }
}

Explanation

• Concise Code: Pattern matching for switch statements allows for more concise and readable code, reducing boilerplate and improving maintainability.
• Flexibility: This feature provides more flexibility in handling different types and patterns in switch statements.

Vector API (Third Incubator)

The Vector API, reintroduced as an incubator feature in Java 18, provides a way to perform vector computations in Java, improving performance for mathematical and scientific applications.

• Vector Computations: The Vector API provides classes and methods for performing vector computations, enhancing performance and efficiency.
• Performance: This feature improves the performance of applications that require intensive mathematical and scientific computations.

Foreign Function & Memory API (Second Incubator)

The Foreign Function & Memory API, reintroduced as an incubator feature in Java 18, provides a way to interact with native code and memory, enhancing interoperability and performance.

• Interoperability: The Foreign Function & Memory API improves interoperability with native code and memory, allowing Java applications to interact with native libraries more efficiently.
• Performance: This feature enhances performance by providing more direct access to native memory and functions.

6. Deprecations and Deletions

Deprecate Finalization for Removal

Java 18 deprecates finalization for removal, encouraging developers to use more modern and reliable alternatives for resource management.

Terminally Deprecate Thread.stop

Java 18 terminally deprecates the Thread.stop method, as it is inherently unsafe and can cause deadlock issues. Developers are encouraged to use safer alternatives for thread management, such as interrupting threads.

Remove the Legacy PlainSocketImpl and PlainDatagramSocketImpl Implementation

• The legacy PlainSocketImpl and PlainDatagramSocketImpl implementations are removed, reflecting their outdated nature and limited use.
• Modern Implementations: Developers are encouraged to use the modern socket implementations provided in Java 18, which offer better performance and reliability.

7. Other Changes in Java 18

Reimplement Core Reflection with Method Handles

Java 18 reimplements core reflection using method handles, improving performance and flexibility for reflective operations.

• Method Handles: Reimplementing core reflection with method handles enhances performance and flexibility, providing a more efficient way to perform reflective operations.
• Performance: This feature improves the performance of reflective operations, making them more efficient and reliable.

ZGC / SerialGC / ParallelGC Support String Deduplication

Java 18 introduces string deduplication support for ZGC, SerialGC, and ParallelGC, reducing memory usage by eliminating duplicate strings.

• Memory Efficiency: String deduplication reduces memory usage by eliminating duplicate strings, improving the efficiency of memory management.
• Garbage Collectors: This feature enhances the capabilities of ZGC, SerialGC, and ParallelGC, providing better performance and memory efficiency.

Allow G1 Heap Regions up to 512 MB

Java 18 allows G1 heap regions to be up to 512 MB in size, improving the scalability and performance of the G1 garbage collector.

• Scalability: Increasing the maximum size of G1 heap regions improves the scalability of the G1 garbage collector, allowing it to handle larger heaps more efficiently.
• Performance: This feature enhances the performance of the G1 garbage collector, providing better memory management for large applications.

Conclusion

Java 18 introduces several key features and improvements, including UTF-8 as the default charset, a simple web server, and enhanced pseudo-random number generators. These features enhance developer productivity, application performance, and the flexibility of the Java platform. By understanding and leveraging these features, developers can build more efficient and maintainable Java applications.

For a complete list of all changes in Java 18, refer to the official Java 18 release notes.

Series: Java Release-wise New Features

• Java 8 Features
• Java 9 Features
• Java 10 Features
• Java 11 Features
• Java 12 Features
• Java 13 Features
• Java 14 Features
• Java 15 Features
• Java 16 Features
• Java 17 Features
• Java 18 Features
• Java 19 Features
• Java 20 Features
• Java 21 Features