Java 8 Features

Java 8 introduced a number of significant features aimed at making the language more functional and improving developer productivity. These features include lambdas, method references, default methods, streams, and more.

1. Lambda Expressions

Lambda expressions provide a clear and concise way to represent a function interface (an interface with a single abstract method) using an expression. They enable functional programming in Java.

// Syntax: (parameters) -> expression
Runnable r = () -> System.out.println("Hello, Lambda!");
r.run();

2. Functional Interfaces

A functional interface is an interface that contains exactly one abstract method. Java 8 provides several built-in functional interfaces such as Function, Predicate, and Supplier.

@FunctionalInterface
interface MyFunctionalInterface {
    void execute();
}

MyFunctionalInterface func = () -> System.out.println("Functional Interface Example");
func.execute();

3. Method References

Method references allow you to refer to methods by their names rather than invoking them. They are used as shorthand for lambda expressions calling a specific method.

// Reference to a static method
Function<Integer, Double> sqrtFunc = Math::sqrt;
double result = sqrtFunc.apply(16); // Returns 4.0

4. Streams API

The Streams API allows for functional-style operations on collections and sequences of data, enabling operations such as map, filter, and reduce. Streams help process data in a declarative way.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList()); // Returns [2, 4]

5. Default Methods in Interfaces

Java 8 allows interfaces to have methods with a default implementation using the default keyword. This provides backward compatibility for older versions of interfaces.

interface MyInterface {
    void normalMethod();

    default void defaultMethod() {
        System.out.println("This is a default method");
    }
}

class MyClass implements MyInterface {
    public void normalMethod() {
        System.out.println("Implementing normal method");
    }
}

MyClass obj = new MyClass();
obj.normalMethod();
obj.defaultMethod();

6. Optional Class

The Optional class provides a way to deal with null values in a more elegant way by wrapping the object that may or may not be present.

Optional<String> optional = Optional.ofNullable(null);
System.out.println(optional.orElse("Default Value")); // Prints "Default Value"

7. New Date and Time API

Java 8 introduced a new, more flexible and comprehensive Date and Time API under the java.time package.

LocalDate today = LocalDate.now();
System.out.println(today); // Prints the current date
LocalDate futureDate = today.plusDays(10);
System.out.println(futureDate); // Prints a date 10 days in the future

8. Collectors Class

The Collectors class in the Streams API provides reduction operations like converting streams into collections or summarizing elements.

List<String> names = Arrays.asList("John", "Jane", "Jack");
String result = names.stream()
    .collect(Collectors.joining(", "));
System.out.println(result); // Prints "John, Jane, Jack"

9. Parallel Streams

Parallel streams allow for parallel processing of stream data, improving performance for large datasets by utilizing multiple threads.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.parallelStream().forEach(System::out::println);

10. Nashorn JavaScript Engine

Java 8 introduced the Nashorn JavaScript engine, which allows for executing JavaScript code within the Java Virtual Machine (JVM).

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
engine.eval("print('Hello, Nashorn!')");

Additional Java 8 Features with Examples

11. Predicate Interface

The Predicate interface represents a boolean-valued function that takes one argument. It's a functional interface commonly used for filtering operations in streams.

Predicate<Integer> isEven = n -> n % 2 == 0;
System.out.println(isEven.test(4)); // Prints true

12. Consumer Interface

The Consumer interface represents an operation that accepts a single input argument and returns no result. It is commonly used in forEach loops to perform actions on stream elements.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System::out::println); // Prints each name

13. Supplier Interface

The Supplier interface represents a supplier of results. It is a functional interface that does not take any arguments but returns a result.

Supplier<String> stringSupplier = () -> "Hello, World!";
System.out.println(stringSupplier.get()); // Prints "Hello, World!"

14. BinaryOperator Interface

The BinaryOperator interface takes two arguments of the same type and returns a result of the same type. It's often used in operations like addition or multiplication.

BinaryOperator<Integer> sum = (a, b) -> a + b;
System.out.println(sum.apply(5, 10)); // Prints 15

15. Stream Reduce Operation

The reduce() method in the Streams API is used to combine elements of a stream into a single result using an accumulator function.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .reduce(0, (a, b) -> a + b);
System.out.println(sum); // Prints 15

16. Stream Map Operation

The map() method is used to transform elements of a stream by applying a function to each element.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> upperCaseNames = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(upperCaseNames); // Prints [ALICE, BOB, CHARLIE]

17. Stream FlatMap Operation

The flatMap() method is used to flatten nested collections and map each element to a new stream.

List<List<String>> nestedList = Arrays.asList(
    Arrays.asList("one", "two"),
    Arrays.asList("three", "four")
);
List<String> flatList = nestedList.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());
System.out.println(flatList); // Prints [one, two, three, four]

18. Peek Operation in Streams

The peek() method allows for inspecting elements of a stream without modifying them. It's useful for debugging intermediate operations.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> result = names.stream()
    .peek(System::out::println)
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(result); // Prints [ALICE, BOB, CHARLIE]

19. Primitive Streams

Java 8 provides specialized stream types for primitive data types, such as IntStream, DoubleStream, and LongStream, for more efficient processing of large datasets.

IntStream.range(1, 5).forEach(System::out::println); // Prints numbers 1 to 4

20. Stream Sorted Operation

The sorted() method in streams allows sorting of elements either naturally or using a comparator.

List<String> names = Arrays.asList("Charlie", "Bob", "Alice");
List<String> sortedNames = names.stream()
    .sorted()
    .collect(Collectors.toList());
System.out.println(sortedNames); // Prints [Alice, Bob, Charlie]

Java 11 Features

Java 11, released in September 2018, is a Long-Term Support (LTS) release that brings several new features and enhancements to the Java platform. It continues to improve performance, security, and developer productivity.

1. New Features in Java 11

  (var a, var b) -> a + b

  java HelloWorld.java

  String s = "  text  ";
  String trimmed = s.strip(); // "text"

• New HTTP Client API: The new java.net.http package introduces a modern HTTP client that supports HTTP/2 and WebSocket. This API replaces the old HttpURLConnection and provides a more efficient way to handle HTTP requests and responses.
• Local-Variable Syntax for Lambda Parameters: Java 11 allows the use of var in lambda expressions. This feature simplifies the declaration of local variables in lambda parameters:
• Flight Recorder: Java Flight Recorder (JFR) is a low-overhead profiling and diagnostics tool that provides insights into the performance and behavior of Java applications. It is now included in the JDK as a commercial feature.
• JEP 330: Launch Single-File Source-Code Programs: Java 11 introduces the capability to run a single Java source file directly from the command line using the java command:
• JEP 321: HTTP/2 Client: This feature introduces a new HTTP client API for making HTTP requests and handling responses, with support for HTTP/2 and WebSocket.
• Removal of Java EE and CORBA Modules: Java 11 removes the javax.xml.bind, javax.xml.ws, and javax.annotation modules, as well as CORBA-related modules, from the JDK.
• New String Methods: Several new methods are added to the String class, including isBlank(), lines(), strip(), stripLeading(), and stripTrailing(), enhancing text processing capabilities:
• Improved Garbage Collection: Java 11 introduces improvements to the G1 garbage collector and the ZGC (Z Garbage Collector) as an experimental feature for low-latency garbage collection.
• Deprecated and Removed Features: Various deprecated and obsolete features are removed or updated in this release to streamline the Java platform.

2. Example Usage of New Features

Here’s a quick example demonstrating the new HTTP Client API:

  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;

  public class HttpExample {
    public static void main(String[] args) throws Exception {
      HttpClient client = HttpClient.newHttpClient();
      HttpRequest request = HttpRequest.newBuilder()
        .uri(new URI("https://api.example.com/data"))
        .build();
      HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
      System.out.println(response.body());
    }
  }

This example shows how to use the new HTTP Client API to send a GET request and print the response body.

Java 17 Features

Java 17, released in September 2021, is a Long-Term Support (LTS) release that includes several major enhancements and new features. It builds on previous versions by adding new capabilities and improving existing ones.

1. New Features in Java 17

  public sealed class Shape permits Circle, Rectangle {
    // Class body
  }

  public final class Circle extends Shape {
    // Class body
  }

  public final class Rectangle extends Shape {
    // Class body
  }

  if (obj instanceof String s) {
    // Use s as a String
  }

  public record Person(String name, int age) {}

  Person person = new Person("Alice", 30);
  System.out.println(person.name()); // Alice

  String json = """
  {
    "name": "Alice",
    "age": 30
  }
  """;

  // Example usage will be provided in future releases

  RandomGenerator rng = RandomGenerator.of("L32X64MixRandom");
  int randomInt = rng.nextInt();

• Sealed Classes: Sealed classes, introduced in JEP 409, allow developers to define a limited set of subclasses. This feature enhances code safety and maintainability by controlling which classes can extend a given class:
• Pattern Matching for instanceof: JEP 394 introduces pattern matching for the instanceof operator, simplifying type checks and casts:
• Records: Records, finalized in JEP 395, provide a compact syntax for defining immutable data classes. Records automatically generate getters, equals(), hashCode(), and toString() methods:
• Text Blocks: Text blocks, introduced in JEP 395, simplify the creation of multi-line string literals, improving readability and maintenance:
• Foreign Function & Memory API (Incubator): JEP 412 introduces the Foreign Function & Memory API, allowing Java programs to interact with native code and manage memory outside the Java heap. This API is in the incubator phase and aims to improve performance and interoperability:
• Enhanced Random Number Generation: JEP 356 improves random number generation by introducing new interfaces and implementations, including a new RandomGenerator interface:
• Deprecations and Removals: Several features have been deprecated or removed in Java 17, including the Applet API and the Security Manager. These changes help streamline the JDK and encourage the use of more modern alternatives.

2. Example Usage of New Features

Here’s a quick example demonstrating the use of pattern matching for instanceof:

  public class PatternMatchingExample {
    public static void printLength(Object obj) {
      if (obj instanceof String s) {
        System.out.println(s.length());
      }
    }

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

This example shows how pattern matching simplifies type checking and casting.

Java 19 Features

Java 19, released in September 2022, includes several new features and enhancements aimed at improving performance, developer productivity, and language capabilities. These features are part of the ongoing evolution of the Java platform.

1. New Features in Java 19

  public class RecordPatternExample {
    public static void printRecordDetails(Object obj) {
      if (obj instanceof Person var (Person(String name, int age))) {
        System.out.println(name + " is " + age + " years old.");
      }
    }

    public static void main(String[] args) {
      printRecordDetails(new Person("Alice", 30));
    }
  }

  public static void printDayType(Object day) {
    switch (day) {
      case Monday:
      case Tuesday:
      case Wednesday:
      case Thursday:
      case Friday:
        System.out.println("Weekday");
        break;
      case Saturday:
      case Sunday:
        System.out.println("Weekend");
        break;
      default:
        System.out.println("Unknown day");
    }
  }

  import java.util.concurrent.Executors;

  public class VirtualThreadsExample {
    public static void main(String[] args) {
      try (var executor = Executors.newVirtualThreadExecutor()) {
        for (int i = 0; i < 10; i++) {
          executor.submit(() -> {
            System.out.println("Running in virtual thread");
          });
        }
      }
    }
  }

  import java.util.concurrent.StructuredTaskScope;

  public class StructuredConcurrencyExample {
    public static void main(String[] args) throws InterruptedException {
      try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        scope.fork(() -> {
          Thread.sleep(1000);
          return 42;
        });
        int result = scope.join().get();
        System.out.println("Result: " + result);
      }
    }
  }

  import jdk.incubator.foreign.*;

  public class ForeignMemoryExample {
    public static void main(String[] args) {
      // Example usage will be provided in future releases
    }
  }

• Record Patterns (Preview): JEP 405 introduces record patterns, which enhance the pattern matching capabilities for records. This feature simplifies extracting data from records and improves code readability:
• Pattern Matching for Switch (Second Preview): JEP 427 enhances the pattern matching capabilities in switch expressions and statements, making them more flexible and concise:
• Virtual Threads (Second Preview): JEP 429 introduces virtual threads, aiming to simplify concurrent programming by making it easier to work with many threads. Virtual threads are lightweight threads managed by the Java Virtual Machine:
• Structured Concurrency (Incubator): JEP 428 aims to simplify multi-threaded programming by providing a more consistent and predictable concurrency model. It introduces a new API for structured concurrency:
• Foreign Function & Memory API (Third Incubator): JEP 433 continues to evolve the Foreign Function & Memory API, which allows Java programs to interface with native code and manage memory outside the Java heap:
• Deprecations and Removals: As with each release, Java 19 includes deprecations and removals of outdated or obsolete features to streamline the platform and encourage the use of modern alternatives.

2. Example Usage of New Features

Here’s an example using pattern matching for switch:

  public class PatternMatchingSwitchExample {
    public static void printDayType(Object day) {
      switch (day) {
        case Monday:
        case Tuesday:
        case Wednesday:
        case Thursday:
        case Friday:
          System.out.println("Weekday");
          break;
        case Saturday:
        case Sunday:
          System.out.println("Weekend");
          break;
        default:
          System.out.println("Unknown day");
      }
    }

    public static void main(String[] args) {
      printDayType("Tuesday");
    }
  }

Java 21 Features

Java 21, released in September 2023, includes several significant updates and new features that enhance the language, performance, and developer productivity. These updates build on previous releases and introduce new capabilities to the Java platform.

1. New Features in Java 21

  public static void printDayType(Object day) {
    switch (day) {
      case Monday:
      case Tuesday:
      case Wednesday:
      case Thursday:
      case Friday:
        System.out.println("Weekday");
        break;
      case Saturday:
      case Sunday:
        System.out.println("Weekend");
        break;
      default:
        System.out.println("Unknown day");
    }
  }

  public class RecordPatternExample {
    public static void printRecordDetails(Object obj) {
      if (obj instanceof Person var (Person(String name, int age))) {
        System.out.println(name + " is " + age + " years old.");
      }
    }

    public static void main(String[] args) {
      printRecordDetails(new Person("Alice", 30));
    }
  }

  import java.util.concurrent.Executors;

  public class VirtualThreadsExample {
    public static void main(String[] args) {
      try (var executor = Executors.newVirtualThreadExecutor()) {
        for (int i = 0; i < 10; i++) {
          executor.submit(() -> {
            System.out.println("Running in virtual thread");
          });
        }
      }
    }
  }

  import java.util.concurrent.StructuredTaskScope;

  public class StructuredConcurrencyExample {
    public static void main(String[] args) throws InterruptedException {
      try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        scope.fork(() -> {
          Thread.sleep(1000);
          return 42;
        });
        int result = scope.join().get();
        System.out.println("Result: " + result);
      }
    }
  }

  import jdk.incubator.foreign.*;

  public class ForeignMemoryExample {
    public static void main(String[] args) {
      // Example usage will be provided in future releases
    }
  }

• Pattern Matching for Switch (Standard Feature): Pattern matching for switch expressions and statements, introduced in preview in Java 19 and 20, is now a standard feature. This enhancement simplifies complex conditional logic and improves readability:
• Record Patterns (Standard Feature): Record patterns, which simplify data extraction from record types, are now standard. This feature enhances readability and reduces boilerplate code:
• Virtual Threads (Standard Feature): Virtual threads, introduced in preview in Java 19 and 20, are now a standard feature. They provide a lightweight concurrency model that simplifies the creation and management of threads:
• Structured Concurrency (Second Incubator): Structured concurrency, introduced as an incubating feature, is aimed at simplifying multi-threaded programming by providing a more consistent concurrency model. This feature is expected to enhance the management of concurrent tasks:
• Foreign Function & Memory API (Second Incubator): The Foreign Function & Memory API continues its incubation phase, offering an API to interface with native code and manage off-heap memory. This API aims to provide a safer and more efficient way to work with native libraries:
• Deprecations and Removals: Java 21 includes deprecations and removals of outdated or obsolete features to streamline the JDK and encourage modern alternatives.

2. Example Usage of New Features

Here’s an example demonstrating the use of virtual threads:

  public class VirtualThreadExample {
    public static void main(String[] args) {
      try (var executor = Executors.newVirtualThreadExecutor()) {
        executor.submit(() -> {
          System.out.println("Hello from virtual thread!");
        }).join();
      }
    }
  }

Java 24 Features

Important Note: As of late 2024, Java 24 is not yet released. The current latest version is Java 23 (released September 2024). Java 24 is expected in March 2025.

However, based on the current development cycle and OpenJDK proposals, here are the planned and potential features for Java 24:

Confirmed/Targeted Features for JDK 24

1. Vector API (Seventh Incubator)

• JEP 960: Further refinements to the Vector API

• Performance improvements and API enhancements

• Continues incubation from previous versions

// Example of Vector API usage (subject to change)
FloatVector a = FloatVector.fromArray(FLOAT_SPECIES, arrayA, 0);
FloatVector b = FloatVector.fromArray(FLOAT_SPECIES, arrayB, 0);
FloatVector c = a.add(b).mul(a);
c.intoArray(result, 0);

2. Structured Concurrency (Second Preview)

• JEP 476: Continues refinement of structured concurrency

• Improves error handling and cancellation

• Makes concurrent programming more reliable 

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> user = scope.fork(() -> findUser());
    Future<Integer> order = scope.fork(() -> fetchOrder());
    
    scope.join();           // Join both subtasks
    scope.throwIfFailed();  // Propagate errors
    
    return new Response(user.resultNow(), order.resultNow());
} // Both subtasks automatically cancelled if needed

3. Stream Gatherers (Finalization)

• JEP 461: Finalizing the Stream Gatherers API introduced in Java 23

• Enhanced stream processing capabilities

• Custom intermediate operations

List<String> strings = Arrays.asList("a", "b", "c", "d");

// Custom stream operation
List<String> result = strings.stream()
    .gather(Gatherers.windowSliding(2))
    .toList();
// Result: [["a", "b"], ["b", "c"], ["c", "d"]]

Potential Features (Under Consideration)

4. Primitive Types in Patterns (Preview)

• JEP Draft: Pattern matching for primitive types

• Extends pattern matching to work with int, double, etc. 

// Potential syntax
Object obj = 42;
if (obj instanceof int i && i > 0) {
    System.out.println("Positive integer: " + i);
}

5. String Templates (Second Preview)

• JEP Draft: Continued refinement of string templates

• Enhanced security and performance

String name = "John";
int age = 30;
String message = STR."Hello \{name}, you are \{age} years old";

6. Implicitly Declared Classes (Preview)

• JEP Draft: Simplifying Java for beginners

• Allows simpler class declarations for small programs

// Instead of public class HelloWorld { ... }
void main() {
    System.out.println("Hello, World!");
}

7. Class-File API (Incubator)

• JEP Draft: Standard API for parsing, generating, and transforming Java class files

// Potential usage for bytecode manipulation
ClassFile cf = ClassFile.of();
ClassModel classModel = cf.parse(bytes);

Ongoing Projects (May Land in Java 24)

8. Project Loom Updates

• Virtual thread enhancements

• Improved scalability for concurrent applications

9. Project Valhalla

• Value Objects and Primitive Classes

• Enhanced performance for data-intensive applications

// Potential value class syntax
value class Point {
    int x;
    int y;
}

10. Project Panama

• Foreign Function & Memory API improvements

• Better native interoperation

Deprecations and Removals

Java 24 will likely continue the trend of removing older features:

• Potential removal of deprecated elements from earlier versions

• Further deprecation of legacy APIs

• Enhanced warnings for obsolete practices

How to Stay Updated

Since Java 24 is still in development, here's how to track its progress:

1. Official Sources

# Download early access builds
https://jdk.java.net/24/

# Follow OpenJDK discussions
https://openjdk.org/jeps/0

2. Check Current Status

# View targeted JEPs for JDK 24
https://openjdk.org/projects/jdk/24/

3. Try Preview Features

// Compile with preview features
javac --enable-preview --release 24 MyClass.java
java --enable-preview MyClass