Java 8 Features

1. Lambda Expressions: Introduces functional programming, allowing anonymous functions and concise syntax for functional interfaces.
2. Functional Interfaces: Defines an interface with a single abstract method, facilitating lambda expressions. The @FunctionalInterface annotation is used to mark such interfaces.
3. Stream API: Offers a new abstraction, Stream, for processing sequences of elements, enabling functional-style operations like filter, map, reduce, etc.
4. Method References: Provides shorthand notation for lambda expressions, enabling method or constructor references with the :: operator.
5. Optional Class: A container object that may or may not hold a non-null value, enhancing null checks and minimizing NullPointerExceptions.
6. New Date and Time API: The java.time package offers a robust API for date and time handling, addressing issues present in the older java.util.Date and java.util.Calendar classes.
7. Default Methods: Allows interfaces to have method implementations, facilitating interface evolution without breaking existing code.
8. Nashorn JavaScript Engine: Replaces the old Rhino engine, offering better performance and improved compatibility with modern JavaScript standards.
9. Parallel Streams: Facilitates parallel processing of streams using the parallel() method, enhancing performance on multi-core systems.
10. Collectors: Introduces utility methods in the Collectors class for common reduction operations.

// Example of using lambda expressions in Java 8

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

names.forEach(name -> System.out.println(name));

Java 9 Enhancements

1. Improved Process API: Enhancements allow better control over native processes through the new ProcessHandle class.

// Using the ProcessHandle API to get information about the current process

public class ProcessHandleDemo {

public static void main(String[] args) {

ProcessHandle currentProcess = ProcessHandle.current();

System.out.println("Process ID: " + currentProcess.pid());

System.out.println("Is alive? " + currentProcess.isAlive());

}

}

2. Collection Factory Methods: New static factory methods for creating immutable collections conveniently.

// Creating an immutable list using List.of()

List<String> colors = List.of("Red", "Green", "Blue");

System.out.println(colors);

3. Enhanced Stream API: New methods such as takeWhile, dropWhile, and ofNullable improve stream flexibility.

// Example of using takeWhile and dropWhile

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

List<Integer> lessThanThree = numbers.stream()

.takeWhile(n -> n < 3)

.collect(Collectors.toList());

System.out.println("Numbers less than 3: " + lessThanThree);

4. Private Methods in Interfaces: Allows encapsulation of common functionality within an interface.

// Example of an interface with a private method

public interface SampleInterface {

default void publicMethod() {

privateMethod();

}

private void privateMethod() {

System.out.println("Private method in interface");

}

}

5. HTTP/2 Client: A new lightweight HTTP client supporting HTTP/2 and WebSocket.

// Example of using the new HTTP client

HttpClient httpClient = HttpClient.newHttpClient();

HttpRequest httpRequest = HttpRequest.newBuilder()

.GET()

.build();

HttpResponse<String> response = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString());

System.out.println("Response Code: " + response.statusCode());

System.out.println("Response Body: " + response.body());