Java 8 introduced a wealth of new features that have transformed the way developers write code. With functional programming at its core, Java 8 offers more concise and elegant solutions to common programming problems. Understanding these features can help Java professionals write better code faster.

This blog will explore the top 8 Java 8 features that will help professionals stay ahead of the curve. From lambdas to streams, the blog will dive deep into each feature and show ways to leverage them in a code.

Top 8 Java 8 Features With Examples

1. Lambda Expressions

A lambda expression is a short block of code that can be passed around as an argument to a method or stored as a variable. It's a way to define an anonymous function that can, in turn, be used to execute a block of code without the need for a separate class.

Lambda expressions are useful for functional programming because they allow developers to write concise codes. Lambda expressions can reduce the amount of boilerplate code required for tasks like filtering collections or iterating over them.

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

List<Integer> evenNumbers = numbers.stream()

 .filter(n -> n % 2 == 0)

 .collect(Collectors.toList());

In this example, the filter method is used to create a new stream that contains only the even numbers from the original list. The n -> n % 2 == 0 syntax is a lambda expression that defines a predicate that checks whether a given number is even or not.

2. Stream API

Streams in Java 8 provide a concise and functional way of performing operations on collections of data. In a nutshell, streams are a sequence of elements that can be processed in parallel or sequentially. They can be created from various sources, such as lists, sets, and arrays.

Streams allow chaining together multiple operations to transform or filter data without the need for loops or temporary variables. Some common stream operations include map, filter, and reduce.

To create a stream, one can call the stream() method on any collection.

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

Stream<Integer> stream = numbers.stream();

Once the stream is created, one can apply various operations to it. For example, to double each number in the list, professionals may use the map() operation:

List<Integer> doubledNumbers = numbers.stream()

 .map(n -> n * 2)

 .collect(Collectors.toList());

3. forEach() method in the Iterable interface

The forEach() method is a new feature added to the Iterable interface in Java 8. It allows developers to iterate over a collection and perform an action on each element of the collection. The forEach() method takes a java.util.function.Consumer object as an argument, which represents the action to be performed on each element. This allows developers to have their business logic at a separate location, making it easier to reuse.

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

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

In this example, there is a list of names, and the forEach() method is being used to print each name. The lambda expression name -> System.out.println(name) is the action that is performed on each element of the list.

4. Default and static methods in interfaces

Before Java 8, interfaces could only contain abstract methods. This meant that any class implementing the interface had to provide an implementation for all of the methods in the interface. This could lead to a lot of boilerplate code and make it difficult to add new methods to existing interfaces without breaking existing implementations.

Default and static methods were introduced in Java 8 to address these issues. Default methods provide a default implementation for a method in an interface. This means that implementing classes don't need to provide an implementation for that method unless they want to override it. Static methods are similar to regular static methods in classes and provide a way to add utility methods to interfaces.

Here is an example of an interface with a default method:

public interface Shape {

 double area();

 default void printArea() {

 System.out.println("The area is " + area());

 }

}

5. Optional class

In Java, null is often used to indicate the absence of a value. However, this can lead to NullPointerExceptions when the code tries to access the properties or methods of a null object. To address this issue, Java 8 introduced the Optional class.

The Optional class is a container object that may or may not contain a value. It is used to represent an optional value that may be null. It helps avoid the NullPointerExceptions as it allows one to check whether a value is present or not before they try to access it.

To use Optional, an instance of it must be created by passing the value one wants to wrap in the Optional constructor. They can then check if the value is present using the isPresent() method. If the value is present, they can retrieve it using the get() method.

Optional<String> optionalValue = Optional.of("hello");

if (optionalValue.isPresent()) {

 String value = optionalValue.get();

 System.out.println(value);

}

In this example, an Optional object is created that contains the string "hello". One must check if the value is present using the isPresent() method, and if it is, they retrieve it using the get() method and print it to the console.

If the value is not present, they can provide a default value using the orElse() method. For example:

Optional<String> optionalValue = Optional.empty();

String value = optionalValue.orElse("default");

System.out.println(value);

6. Date and time API

The previous Date and Calendar APIs in Java had several problems. They were not thread-safe, mutable, and lacked precision. Additionally, the APIs were not intuitive to use, leading to errors and confusion.

To address these problems, Java 8 introduced a new Date and Time API. The new API is designed to be thread-safe and immutable, and it offers enhanced precision and intuitive usage.

The new API offers a variety of classes for working with dates, times, and durations. Some of the most commonly used classes include LocalDate, LocalTime, LocalDateTime, Instant, Duration, and Period. These classes offer various methods for performing common date and time operations. These include parsing, formatting, arithmetic operations, and conversion between different time zones.

Here's an example of how to use the new API to parse a date string and format it using a different pattern:

String dateString = "2022-03-24";

LocalDate date = LocalDate.parse(dateString);

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("EEE, MMM d, yyyy");

String formattedDate = date.format(formatter);

System.out.println(formattedDate); // Output: Thu, Mar 24, 2022

7. Concurrency enhancements

Concurrency programming has always been a challenge in Java due to the limitations of earlier versions of Java. One of the most significant enhancements to the concurrency API is the CompletableFuture class.

CompletableFuture is a powerful tool that simplifies asynchronous programming by allowing developers to chain together multiple asynchronous operations. The class offers a wide range of methods for handling exceptions, combining multiple futures, and composing asynchronous operations.

Another significant enhancement to the concurrency API in Java 8 is the introduction of parallel streams. Parallel streams allow developers to process large datasets in parallel, which can significantly improve performance on multi-core processors. Parallel streams provide a simple and intuitive way to distribute the workload across multiple threads without the need for complex thread synchronization.

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Sequential stream

int sum = list.stream()

.filter(n -> n % 2 == 0)

.mapToInt(Integer::intValue)

.sum();

// Parallel stream

int sumParallel = list.parallelStream()

.filter(n -> n % 2 == 0)

.mapToInt(Integer::intValue)

.sum();

8. Java IO improvements

Java 8 includes several new classes and methods for working with files and directories. One of the most important classes is the Files class, which provides static methods for creating, copying, deleting, and moving files and directories. The Path interface is another new feature that represents the path to a file or directory.

Path source = Paths.get("source.txt");

Path target = Paths.get("target.txt");

try {

Files.copy(source, target);

} catch (IOException e) {

e.printStackTrace();

}

This example demonstrates using the Files.copy() method to copy the file "source.txt" to "target.txt". The Paths.get() method is used to create Path objects representing the source and target files. If an exception occurs during the copy operation, the catch block will handle the exception and print the stack trace.

Conclusion

Java 8 introduced significant enhancements to a programming language, revolutionizing the way developers write code. From lambda expressions and functional interfaces to the Date and Time API, Java 8 has made programming in Java more efficient, readable, and enjoyable.

With the addition of features like the forEach() method in the Iterable interface and IO improvements, developers can now focus more on business logic and less on boilerplate code.

Cogent University understands that education is an investment in one's future. Our boot camp offers a wide range of courses to help individuals and organizations stay up-to-date with the latest technologies and trends.

With expert instructors and a cutting-edge curriculum, one can learn new skills or improve existing ones. Enrol in Cogent University to upgrade professional career one step towards a bright and informed future.