Java 8 Explained In 5 Minutes

Interviewers often ask about Java 8. Don't get stuck. Let's break it down in this article.

Why Was Java 8 Necessary?

The primary reason was that Java was notoriously verbose. Writing simple functionality required numerous lines of code. With the introduction of Java 8's features, this verbosity was significantly reduced, allowing developers to write more readable and concise code.

Secondly, Java lacked support for functional programming. This meant developers couldn't treat logic as data—for instance, passing a function as an argument or assigning it to a variable. This was a major limitation in earlier versions.

Thirdly, Java needed better support for parallel programming. Parallel programming involves breaking down a large task into smaller subtasks and executing them simultaneously on multiple CPU cores. This approach leads to faster results by combining the outcomes of the subtasks.

Before Java 8, implementing parallel programming was cumbersome. It involved a lot of boilerplate code, such as manually creating a thread pool, running tasks, and then combining the results. The process was complex and error-prone.

With the introduction of Java 8, this process became remarkably simple. Now, developers can just call the parallelStream() method on a collection and use methods like map() to transform the data. The code is clean, easy to understand, and not complicated at all. These three key reasons highlight why the introduction of Java 8 was a significant milestone.

Key Improvements in Java 8

So, what exactly changed? Here are three major improvements that came with Java 8:

1. Functional Programming: As mentioned, Java 8 introduced the ability to treat logic as data. You can now pass functions as arguments, assign them to variables, and store them, which opens up a new paradigm of programming in Java.
2. Reduced Boilerplate Code: Boilerplate refers to repetitive code that appears in multiple places with little to no alteration. Before Java 8, reusing certain functionalities was difficult without writing redundant code. Java 8 features drastically reduced the amount of boilerplate required.
3. Simplified Collections Processing: Processing collections of data before Java 8 typically required using an enhanced for-loop. With the introduction of Streams API in Java 8, you can now process collections in a single, declarative line of code. This makes the code more readable and concise compared to older versions.

Must-Know Java 8 Features

Here are several of the most important features introduced in Java 8 that every developer should know:

• Functional Interfaces: An interface that contains exactly one abstract method.
• Default and Static Methods: Java 8 allows interfaces to have methods with implementations, using the default and static keywords.
• Lambda Expressions: These provide a clear and concise way to implement a functional interface by providing an implementation for its abstract method.
• Stream API: For powerful and declarative data processing.
• Optional Class: A container object which may or may not contain a non-null value, used to handle NullPointerException more gracefully.
• Date and Time API: A completely new, more intuitive API for handling dates and times.
• Method References: A shorthand syntax for a lambda expression that executes just ONE method.

Practical Example: The Stream API in Action

Let's dive into a practical example using the Stream API. Streams simplify data processing by allowing you to chain operations like filters, maps, and collectors. When combined with lambda expressions, they result in exceptionally clean and readable code.

Let's consider a common task: filtering even numbers from a list.

With Java 8 Features

Here is how you can accomplish this using the Stream API. First, we create a list of integers:

List<Integer> numbers = Arrays.asList(22, 23, 21, 26, 28);

Now, to filter the even numbers, you can simply call the stream() method on the list, followed by filter(). The filter method accepts a Predicate functional interface, for which we provide a lambda expression n -> n % 2 == 0. This expression returns true for even numbers.

Finally, we use the forEach method to iterate over the filtered elements and print them. We can use a method reference System.out::println for even more concise code.

numbers.stream()
       .filter(n -> n % 2 == 0)
       .forEach(System.out::println);

When you run this code, the output will be the even numbers from the list. It's incredibly straightforward with features like stream, filter, and forEach.

Before Java 8

Now, let's compare this to the pre-Java 8 approach. The code was much more complicated and lengthy.

You would need to initialize a new list to store the filtered results. Then, you would iterate through the original list with a for-each loop, check if each element is even, and if so, add it to the new list.

List<Integer> numbers = Arrays.asList(22, 23, 21, 26, 28);
List<Integer> evenNumbers = new ArrayList<>();
for (Integer n : numbers) {
    if (n % 2 == 0) {
        evenNumbers.add(n);
    }
}

After filtering, you would need another for-loop to iterate through the new list just to print the elements:

for (Integer evenNumber : evenNumbers) {
    System.out.println(evenNumber);
}

Comparing the two approaches, the Java 8 version is clearly superior in terms of readability and conciseness.

Real-World Applications of Java 8 Features

Where are these features actually used in real-world projects?

1. Flexible Interfaces with Default Methods

In a large application, like one built with Spring Boot, you might have interfaces with numerous method contracts. If you need to add a new method to an interface, all implementing classes would break. With default methods, you can add new methods to interfaces without forcing changes in existing implementation classes, making your interfaces more flexible.

2. Avoiding NullPointerExceptions with Optional

Imagine a Spring Boot application that fetches user details from a database using their email. A common way to define this in a repository is:

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

If a user with the given email doesn't exist, the database query will return nothing. Without Optional, this could easily lead to a NullPointerException later in the code. By wrapping the result in an Optional, the method signature clearly communicates that a value might be absent. The calling code is then forced to handle the case where the user is not found, allowing you to provide meaningful feedback instead of crashing the application.

Why Do Interviewers Focus on Java 8?

The main reason interviewers emphasize these features is that they are widely used in modern, real-world projects. A candidate who understands and can apply these concepts demonstrates that they have practical, relevant skills. They are looking for developers who can write clean, efficient, and modern Java code.