Show List
Tutorials > Java > Java 8 Features Explained with Code Examples

Java 8 Features Explained with Code Examples

Java 8 introduced a significant paradigm shift to the language, incorporating functional programming concepts and improving overall code expressiveness. This release brought powerful enhancements like lambda expressions, the Stream API for functional-style data processing, default methods in interfaces, the Optional class for safer null handling, and a robust Date and Time API. These features not only improve developer productivity but also make Java applications more concise and readable. This tutorial covers all major Java 8 features with practical examples, helping you understand when and how to use them in real-world projects.

Java 8 was a major release that introduced several new features and improvements to the Java programming language. Some of the most notable features include:

  1. Lambdas: Lambdas are anonymous functions that can be created without being bound to a name. They provide a concise and efficient way to write functional-style code in Java. For example:
import java.util.Arrays;
import java.util.List; List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); numbers.forEach(n -> System.out.println(n));

In this example, a List of Integers is created and then the forEach method is used to iterate over the elements in the list. The forEach method takes a Consumer functional interface as its argument, which represents an operation that takes a single input argument and returns no result. The lambda expression n -> System.out.println(n) is passed as the argument to the forEach method and represents an operation that takes an Integer as input and prints it to the console.

  1. Streams: Streams are sequences of elements that can be processed in parallel or sequentially. They provide a way to process collections of data in a functional-style. For example:
import java.util.Arrays;
import java.util.List;

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().mapToInt(n -> n).sum();
System.out.println("Sum: " + sum);

In this example, a List of Integers is created and then the stream method is used to create a stream from the elements in the list. The mapToInt method is used to convert the stream of Integers to a stream of primitive ints. The sum method is used to compute the sum of the elements in the stream.

  1. Default Methods: Default methods allow you to add new methods to existing interfaces without breaking existing code. For example:
interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

Formula formula = (a) -> Math.sqrt(a);
System.out.println(formula.calculate(100));
System.out.println(formula.sqrt(16));

In this example, the Formula interface is defined with a single abstract method calculate and a default method sqrt. The Formula interface is then implemented by a lambda expression that implements the calculate method. The sqrt method is automatically available to all implementations of the Formula interface, without requiring any additional code to be written.

  1. Optional: The Optional class is a container object that is used to represent the presence or absence of a value. It provides a way to handle the case where a value may be missing, without using null. For example:
import java.util.Optional;

Optional<String> optional = Optional.of("value");
if (optional.isPresent()) {
    System.out.println(optional.get());
}

In this example, an Optional object is created from a string value. The isPresent method is used to check if the Optional object contains a value, and the get method is used to retrieve the value if it is present. If the Optional object is empty, then the get method will throw an exception. The Optional class provides several other methods for working with optional values, such as orElse and orElseGet, which allow you to specify a default value or a default value supplier to be used if the Optional object is empty.

  1. Date and Time API: The new Date and Time API provides a comprehensive and flexible way to represent and manipulate date and time values. For example:
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

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

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
System.out.println("Date: " + date.format(formatter));
System.out.println("Time: " + time);
System.out.println("Date Time: " + dateTime);

In this example, the LocalDate, LocalTime, and LocalDateTime classes are used to represent date, time, and date-time values, respectively. The now method is used to create a new instance of each class that represents the current date, time, or date-time. The DateTimeFormatter class is used to format the date and time values as strings, using a specified pattern.

These are just a few examples of the new features and improvements that were introduced in Java 8. The new features provide more concise and expressive ways to write code, and make it easier to write functional-style code in Java.

Java 8 transformed the way modern Java is written. Its key features like Lambdas, Streams, Optional, and the new Date-Time API enable more expressive, clean, and maintainable code. Whether you're building large-scale systems or optimizing small utilities, leveraging these features can significantly improve your development experience.


FAQs 

1. What are the main features of Java 8?

Java 8 introduced Lambda expressions, Stream API, default methods, Optional class, and a new Date-Time API.

2. Why are lambdas important in Java 8?

Lambdas allow concise function implementation and support functional programming by enabling behavior to be passed as a parameter.

3. What is the difference between Optional.of and Optional.ofNullable?

Optional.of throws an exception if the value is null, while Optional.ofNullable allows null values and returns an empty Optional.

4. How is the Stream API different from collections?

Streams allow functional-style operations (filter, map, reduce) and support lazy evaluation and parallel processing.

5. What problem does the Optional class solve?

Optional provides a more expressive alternative to null checks, reducing the chances of NullPointerException.

6. Are default methods in interfaces mandatory to override?

No. Classes implementing the interface inherit the default implementation unless explicitly overridden.

7. What is the advantage of the new Date-Time API?

It provides immutable, thread-safe date and time handling, replacing legacy java.util.Date and Calendar.

8. Can streams be reused in Java?

No, Java streams are single-use. Once consumed, a new stream must be created for reuse.



Next: Java CompletableFuture Tutorial with Async Examples

    Leave a Comment

  • captcha text