The critical and useful features added to Java after Java 8

Java 9

1. Module System (Project Jigsaw)

• Introduced the Java Platform Module System, which allows the creation of modular applications.
• Provides better encapsulation and improves application performance.

2. JShell (REPL)

• Interactive tool for learning, prototyping, and testing Java code snippets.

3. Factory Methods for Collections

• New static factory methods for creating immutable collections.

  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. Stream API Improvements

• New methods like takeWhile(), dropWhile(), and iterate() for more functional-style operations.

5. Private Interface Methods

• Interfaces can now have private methods to share code between default methods.

Java 10

1. Local-Variable Type Inference

• Introduced the var keyword, allowing local variable type inference.

  var list = new ArrayList<String>();
  

Java 11

1. New String Methods

• Methods like isBlank(), lines(), strip(), repeat().

  String str = " hello ";
  System.out.println(str.isBlank()); // false
  System.out.println(str.strip()); // "hello"
  System.out.println("repeat".repeat(3)); // "repeatrepeatrepeat"
  

2. Files Methods

• New methods in Files class: writeString(), readString(), isSameFile().

  Path path = Paths.get("example.txt");
  Files.writeString(path, "Hello, World");
  String content = Files.readString(path);
  

3. Running Java Files with java Command

• Simplified execution of single-file programs without needing to compile them first.

  java HelloWorld.java
  

Java 12

1. Switch Expressions (Preview)

• Switch expressions that simplify the code and can return a value.

  int num = 3;
  String result = switch (num) {
      case 1 -> "one";
      case 2 -> "two";
      case 3 -> "three";
      default -> "unknown";
  };
  

2. New Methods in Collectors

• Methods like teeing(), which can combine two collectors into one.

  Collector<T, ?, R1> downstream1 = ...;
  Collector<T, ?, R2> downstream2 = ...;
  Collector<T, ?, R> result = Collectors.teeing(downstream1, downstream2, (r1, r2) -> ...);
  

Java 13

1. Text Blocks (Preview)

• Multi-line string literals for better readability.

  String text = """
      This is a text block.
      It spans multiple lines.
      """;
  

Java 14

1. Records (Preview)

• A new way to create data-carrying classes concisely.

  public record Point(int x, int y) {}
  

2. Pattern Matching for instanceof (Preview)

• Simplifies casting objects after type-checking.

  if (obj instanceof String s) {
      System.out.println(s.toUpperCase());
  }
  

Java 15

1. Sealed Classes (Preview)

• Restricts which classes can extend or implement them.

  public abstract sealed class Shape
      permits Circle, Rectangle, Square {}
  

Java 16

1. Records (Standard)

• Finalized the record feature for concise data classes.

2. Pattern Matching for instanceof (Standard)

• Finalized the pattern matching feature.

3. Stream.toList()

• A method to directly collect stream elements into a list.

  List<String> list = stream.toList();
  

Java 17 (LTS)

1. Sealed Classes (Standard)

• Finalized the sealed classes feature.

2. Enhanced Pseudo-Random Number Generators

• New interface and implementations for better random number generation.

3. New macOS Rendering Pipeline

• New rendering pipeline for macOS to improve performance.

Java 18

1. UTF-8 by Default

• Standardized UTF-8 as the default character set.

2. Simple Web Server (Preview)

• Lightweight web server for prototyping and testing.

3. Code Snippets in Java API Documentation

• Improved documentation with code snippet support.

Java 19

1. Virtual Threads (Preview)

• Lightweight threads for better scalability and performance in concurrent applications.

2. Structured Concurrency (Preview)

• Simplifies multi-threaded programming by managing a group of related tasks.

3. Pattern Matching for switch (Preview)

• Extended pattern matching to switch statements and expressions.

Java 21

1. Virtual Threads (Standard)

• Finalized support for virtual threads (Project Loom), which provide lightweight concurrency and are designed to scale applications more efficiently by reducing the overhead of traditional threads.

  try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
      List<Future<String>> futures = executor.invokeAll(List.of(
          () -> "Task 1",
          () -> "Task 2",
          () -> "Task 3"
      ));
  }
  

2. Structured Concurrency (Standard)

• Structured concurrency simplifies the handling of concurrent tasks by managing the lifecycle of related tasks in a structured and reliable manner.

  try (var scope = new StructuredTaskScope<>()) {
      Future<String> future1 = scope.fork(() -> "Task 1");
      Future<String> future2 = scope.fork(() -> "Task 2");
      scope.join();
      scope.throwIfFailed();
      System.out.println(future1.resultNow());
      System.out.println(future2.resultNow());
  }
  

3. Pattern Matching for switch (Standard)

• Extended pattern matching to switch statements and expressions, allowing more expressive and concise code.

  Object obj = 123;
  String result = switch (obj) {
      case Integer i -> "Integer: " + i;
      case String s -> "String: " + s;
      default -> "Unknown";
  };
  

4. Sequenced Collections

• Introduced new interfaces SequencedCollection, SequencedSet, and SequencedMap which allow for elements to be accessed in a consistent sequence order.

  SequencedSet<String> set = new LinkedHashSet<>();
  set.add("first");
  set.add("second");
  System.out.println(set.getFirst()); // "first"
  System.out.println(set.getLast()); // "second"
  

5. String Templates (Preview)

• String templates simplify the creation of dynamic strings, allowing more readable and maintainable code.

  String name = "World";
  String message = STR."Hello, \{name}!";
  System.out.println(message); // "Hello, World!"
  

6. Generational ZGC

• Enhanced the Z Garbage Collector (ZGC) to include generational capabilities, improving performance and efficiency in memory management.

7. Record Patterns (Preview)

• Extended pattern matching to support record patterns, enabling more concise and readable data extraction from records.

  record Point(int x, int y) {}
  Object obj = new Point(1, 2);
  if (obj instanceof Point(int x, int y)) {
      System.out.println("x: " + x + ", y: " + y);
  }
  

8. Enhanced Nullability Annotations

• Improved support for nullability annotations, aiding in static code analysis and reducing the risk of null pointer exceptions.

These features introduced in Java 21 further enhance the language by improving concurrency, code readability, and performance, making Java more robust and developer-friendly.