Java 9 features with explanation

 Java 9, released in September 2017, introduced a significant number of new features and enhancements, with the module system being the most notable. Here's a comprehensive overview of the major features in Java 9:

1. Java Platform Module System (Project Jigsaw)

• Explanation: Introduced modularization to the Java platform, allowing developers to create and use modules. This feature helps in organizing large codebases and improving encapsulation.
• Example:

  module com.example.module {
      requires java.base;
      exports com.example.package;
  }
  

2. JShell: The Interactive Java REPL

• Explanation: JShell provides an interactive command-line tool to evaluate Java code snippets without the need for a full development environment. It helps in quick testing and learning.
• Example:

  jshell> int x = 10;
  jshell> System.out.println(x + 2);
  

3. Collection Factory Methods

• Explanation: Simplified creation of immutable collections using static factory methods in List, Set, and Map interfaces.
• Example:

  List<String> list = List.of("a", "b", "c");
  Set<String> set = Set.of("a", "b", "c");
  Map<String, String> map = Map.of("key1", "value1", "key2", "value2");
  

4. Private Interface Methods

• Explanation: Allows interfaces to have private methods, which can be used to share common code between default and static methods.
• Example:

  interface MyInterface {
      private void privateMethod() {
          // Common code
      }
  
      default void defaultMethod() {
          privateMethod();
      }
  }
  

5. Stream API Enhancements

• Explanation: Added new methods to the Stream API, such as takeWhile(), dropWhile(), iterate(), and ofNullable().
• Example:

  List<Integer> list = List.of(1, 2, 3, 4, 5);
  list.stream().takeWhile(n -> n < 4).forEach(System.out::println);
  

6. Optional Enhancements

• Explanation: Added new methods like ifPresentOrElse(), or(), and stream() to the Optional class.
• Example:

  Optional<String> optional = Optional.of("Hello");
  optional.ifPresentOrElse(System.out::println, () -> System.out.println("Value is absent"));
  

7. HTTP/2 Client (Incubator)

• Explanation: Introduced a new HTTP client API to support HTTP/2 and WebSocket. Initially provided as an incubator module (jdk.incubator.http).
• Example:

  HttpClient client = HttpClient.newHttpClient();
  HttpRequest request = HttpRequest.newBuilder()
                                   .uri(URI.create("http://example.com"))
                                   .build();
  HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
  System.out.println(response.body());
  

8. Multi-Release JAR Files

• Explanation: Allows JAR files to contain version-specific class files, enabling compatibility with multiple versions of the Java runtime.
• Example:

  mylibrary.jar
  ├── META-INF
  │   └── versions
  │       └── 9
  │           └── com
  │               └── example
  │                   └── MyClass.class
  └── com
      └── example
          └── MyClass.class
  

9. Process API Improvements

• Explanation: Enhanced the Process API to provide more control and information about operating system processes.
• Example:

  ProcessHandle currentProcess = ProcessHandle.current();
  System.out.println("PID: " + currentProcess.pid());
  currentProcess.children().forEach(child -> System.out.println("Child PID: " + child.pid()));
  

10. Deprecated and Removed Features

• Explanation: Deprecated some older features and APIs, including the Applet API, and removed features like the JVM options -Xprof and -Xfuture.

11. Multi-Resolution Images API

• Explanation: Added a new java.awt.image.MultiResolutionImage API to support multiple versions of an image in a single image object.
• Example:

  MultiResolutionImage multiResolutionImage = (MultiResolutionImage) image;
  Image variant = multiResolutionImage.getResolutionVariant(32, 32);
  

12. Enhanced Deprecation

• Explanation: Added the ability to specify forRemoval and since attributes in the @Deprecated annotation.
• Example:

  @Deprecated(since = "9", forRemoval = true)
  public void oldMethod() {
      // Code
  }
  

13. Unified JVM Logging

• Explanation: Introduced a common logging system for all components of the JVM, making it easier to configure and manage logs.
• Example:

  java -Xlog:gc*=info:file=gc.log
  

14. Stack-Walking API

• Explanation: Introduced the java.lang.StackWalker API to provide a more flexible and efficient mechanism for stack walking.
• Example:

  StackWalker walker = StackWalker.getInstance();
  walker.forEach(frame -> System.out.println(frame.getClassName() + " " + frame.getMethodName()));
  

15. Compact Strings

• Explanation: Optimized the String class to use a more compact representation internally, reducing memory footprint.
• Impact: Improves memory efficiency without changing the external behavior of the String class.

16. Segmented Code Cache

• Explanation: Improved performance by dividing the code cache into distinct segments: non-method, profiled, and non-profiled methods.
• Impact: Enhances JVM performance and maintainability.

These features collectively make Java 9 a significant release, enhancing modularity, performance, and ease of use for developers.