NUHMAN.com

Java 8 introduced several significant features that brought functional programming concepts into the language. Here’s an overview of some of the most important features you should know about.

🔹 1. Lambda Expressions

Lambda expressions provide a clear and concise way to express instances of single-method interfaces (functional interfaces).

• Syntax:
• (parameter) -> expression
• Example:

java

(int a, int b) -> a + b;

• Use Case:
• Lambda expressions help reduce boilerplate code, especially when working with functional interfaces, such as in collections, streams, etc.

🔹 2. Functional Interfaces

A functional interface is an interface with just one abstract method, and it can be used with lambda expressions.

• Common Built-In Functional Interfaces:
• Predicate – for boolean-valued functions
• Function – for functions that take one argument and return a result
• Consumer – for functions that consume input but don’t return anything
• Supplier – for functions that provide a result without input
• Example:

java

Predicate<Integer> isEven = (n) -> n % 2 == 0;

🔹 3. Streams API

The Streams API allows you to process sequences of elements (like collections) in a functional style.

• Key Operations:
• map() – transforms elements
• filter() – filters elements
• reduce() – combines elements
• collect() – gathers results
• Example:

java

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squared = numbers.stream()
                              .map(n -> n * n)
                              .collect(Collectors.toList());

🔹 4. Default Methods

Java 8 introduced default methods in interfaces, allowing you to add new methods to interfaces without breaking existing implementations.

• Example:

java

interface MyInterface {
    default void greet() {
        System.out.println("Hello from the interface!");
    }
}

• Use Case:
• Default methods help maintain backward compatibility in interfaces.

🔹 5. Method References

Method references simplify the use of lambda expressions by referring directly to a method using the :: operator.

• Types:
• Static Method Reference:
• ClassName::methodName
• Instance Method Reference:
• instance::methodName
• Constructor Reference:
• ClassName::new
• Example:

java

List<String> names = Arrays.asList("Anna", "Mike", "John");
names.forEach(System.out::println);

🔹 6. Optional Class

The Optional class is used to avoid NullPointerExceptions and represents a container that may or may not hold a value.

• Use Case:
• It helps to write safer code by explicitly indicating the potential absence of a value.
• Example:

java

Optional<String> name = Optional.ofNullable(getName());
name.ifPresent(n -> System.out.println("Hello, " + n));

🔹 7. New Date and Time API

Java 8 introduced a completely new Date and Time API that is immutable, thread-safe, and much easier to use compared to java.util.Date.

• Classes:
• LocalDate – Date without time
• LocalTime – Time without date
• LocalDateTime – Both date and time
• ZonedDateTime – Date and time with time zone information
• Example:

java

LocalDate date = LocalDate.now();
LocalTime time = LocalTime.now();

🔹 8. Stream API Enhancements

Java 8 enhanced the Stream API with new methods like flatMap() and distinct(), making it more powerful and versatile for handling data transformations.

• Additional Methods:
• flatMap() – Converts each element into a stream and merges the results.
• distinct() – Removes duplicate elements.

🔹 9. Nashorn JavaScript Engine

Java 8 introduced the Nashorn JavaScript engine, allowing Java applications to execute JavaScript code. It provides improved performance compared to the previous Rhino engine.

• Example:

java

ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
engine.eval("print('Hello from JavaScript');");

🔹 10. Concurrency Updates

Java 8 introduced new concurrency utilities like CompletableFuture for asynchronous programming and improvements to ConcurrentHashMap.

• CompletableFuture:
• Enables writing asynchronous non-blocking code that can combine results and handle exceptions.
• Example:

java

CompletableFuture.supplyAsync(() -> "Hello")
                 .thenApply(result -> result + " World!")
                 .thenAccept(System.out::println);

🧠 Conclusion

Java 8 significantly improved the language with the introduction of functional programming concepts and new API enhancements. The Streams API, lambda expressions, default methods, and other features make Java more concise, readable, and powerful, allowing developers to write cleaner, more efficient code.