What are Java 8 features?

Java 8, released in March 2014, was a significant release that brought about a paradigm shift in how Java developers write code, primarily by introducing functional programming constructs. It aimed to improve developer productivity, leverage multi-core processors more effectively, and enhance the readability and conciseness of Java code. Here are some of its most important features:

Lambda Expressions

Lambda expressions provide a clear and concise way to represent an anonymous function. They allow you to treat functionality as a method argument, or code as data. This is particularly useful for implementing functional interfaces (interfaces with a single abstract method) and significantly reduces boilerplate code for anonymous inner classes.

// Before Java 8
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from a separate thread!");
    }
}).start();

// With Java 8 Lambda Expression
new Thread(() -> System.out.println("Hello from a separate thread!")).start();

Stream API

The Stream API is a powerful tool for processing collections of data in a functional and declarative way. It supports sequential and parallel operations on data sources like collections, arrays, and I/O channels. Streams allow you to perform filter, map, reduce, and other operations efficiently, often in parallel, without explicitly writing complex loops.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
long count = names.stream()
                  .filter(name -> name.startsWith("A"))
                  .count(); // count = 1

List<String> upperCaseNames = names.stream()
                                 .map(String::toUpperCase)
                                 .collect(Collectors.toList()); // ["ALICE", "BOB", "CHARLIE", "DAVID"]

Default Methods (Defender Methods)

Default methods enable adding new functionality to interfaces in a backward-compatible way. This means you can add new methods to an interface without breaking existing classes that implement that interface. They have an implementation provided directly within the interface using the default keyword.

interface MyInterface {
    void abstractMethod();

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

Functional Interfaces

A functional interface is an interface that has exactly one abstract method. These interfaces are key to using lambda expressions, as lambdas provide the implementation for that single abstract method. Java 8 introduced the @FunctionalInterface annotation to explicitly mark interfaces as such, though it's not strictly required.

• java.util.function.Predicate<T>: Represents a predicate (boolean-valued function) of one argument.
• java.util.function.Consumer<T>: Represents an operation that accepts a single input argument and returns no result.
• java.util.function.Function<T, R>: Represents a function that accepts one argument and produces a result.
• java.util.function.Supplier<T>: Represents a supplier of results.

Date and Time API (`java.time`)

The new Date and Time API, located in the java.time package, addresses many of the shortcomings of the old java.util.Date and java.util.Calendar classes. It provides immutable, thread-safe classes for handling dates, times, instants, and durations, offering better clarity, consistency, and separation of concerns.

LocalDate today = LocalDate.now();
LocalTime now = LocalTime.now();
LocalDateTime currentDateTime = LocalDateTime.now();
ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("America/New_York"));

Optional Class

java.util.Optional<T> is a container object that may or may not contain a non-null value. It's designed to help developers write more robust and readable code by explicitly indicating the potential absence of a value, thereby reducing the chances of NullPointerExceptions.

String name = null;
Optional<String> optionalName = Optional.ofNullable(name);

System.out.println(optionalName.orElse("Default Name")); // Output: Default Name

name = "Alice";
optionalName = Optional.ofNullable(name);
System.out.println(optionalName.orElse("Default Name")); // Output: Alice

Method References

Method references are compact, readable syntax for lambda expressions that simply call an existing method. They make your code even more concise by referring to methods by their names.

• Static method reference (ClassName::staticMethodName)
• Instance method reference of a particular object (object::instanceMethodName)
• Instance method reference of an arbitrary object of a particular type (ClassName::instanceMethodName)
• Constructor reference (ClassName::new)

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

// Using lambda
names.forEach(s -> System.out.println(s));

// Using method reference
names.forEach(System.out::println);

Nashorn JavaScript Engine

Nashorn is a JavaScript engine that allows Java applications to embed and run JavaScript code directly on the JVM. It replaced the older Rhino engine and offered better performance and compliance with ECMAScript 5.1.

Parallel Array Sorting

Java 8 introduced Arrays.parallelSort() for sorting large arrays. This method leverages the Fork/Join Framework to sort arrays in parallel, which can offer significant performance improvements on multi-core processors for large datasets.