Java 8 Cheat Sheet

Introduction

Java 8 brought significant improvements and new features to the Java programming language. These features are designed to improve developer productivity, enable functional programming, and enhance performance. This cheat sheet covers the most important concepts and features introduced in Java 8.

Learn everything about Java and Java 8: Learn Java Programming.

Java 8 Concepts and Features

Feature	Description
Lambda Expressions	A lambda expression is simply a function without a name. It can even be used as a parameter in a function. Lambda Expressions facilitate functional programming and simplify development greatly.
Functional Interfaces	A functional interface in Java is an interface that has exactly one abstract method. Functional Interfaces with only one abstract method can be easily implemented using lambda expressions.
Stream API	Stream API provides a way to process collections of objects in a functional style, making operations like filtering, mapping, and reducing easier.
Optional Class	The Optional class helps you avoid NullPointerException by providing a container that may or may not hold a non-null value.
Default Methods	Default methods in Java 8 are methods in an interface with a default implementation. They allow interfaces to add new methods without breaking existing implementations.
Method References	Simplifies lambda expressions by allowing you to refer to methods directly by their names.
Date and Time API (java.time)	Introduces a new, more powerful and flexible API for handling dates and times, replacing the old java.util.Date and Calendar classes.
Collectors	A utility class that provides methods to accumulate elements from a stream into various forms like lists, sets, or strings.
Parallel Streams	Enables parallel processing of collections to make use of multiple cores, improving performance for large data sets.
forEach() Method	Simplifies iteration over collections by applying a specified action to each element.
Map API Enhancements	Adds new methods to the Map interface like compute(), getOrDefault(), forEach(), which make working with maps more efficient.
Nashorn JavaScript Engine	A new lightweight, high-performance JavaScript engine integrated into the JVM that allows you to run JavaScript code from within Java.
Parallel Arrays	Enhances the Arrays class to support parallel operations on arrays, which can improve performance for large arrays.
Base64 Encoding and Decoding	Provides built-in utility classes for encoding and decoding data in Base64 format.

Explanation and Examples of Java 8 Features

Lambda Expressions

A lambda expression is simply a function without a name. It can even be used as a parameter in a function. Lambda Expressions facilitate functional programming and simplify development. The main use of lambda expression is to provide an implementation for functional interfaces.

Example:

List<String> names = Arrays.asList("John", "Jane", "Jack");
names.forEach(name -> System.out.println(name));

Explanation: The lambda expression name -> System.out.println(name) simplifies the code needed to iterate through a list and print each element.

Functional Interfaces

A functional interface has exactly one abstract method and can be represented using lambda expressions.

Example:

@FunctionalInterface
interface MyFunctionalInterface {
    void myMethod();
}

MyFunctionalInterface func = () -> System.out.println("Hello, World!");
func.myMethod();

Explanation: The MyFunctionalInterface has one method, myMethod(), and is implemented using a lambda expression.

Stream API

The Stream API provides a functional approach to process sequences of elements, enabling operations like filter, map, reduce, etc.

Example:

List<String> names = Arrays.asList("John", "Jane", "Jack");
List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("J"))
                                  .collect(Collectors.toList());

Explanation: The stream pipeline filters the list to include only names starting with "J" and collects the result into a new list.

Optional Class

The Optional class is a container object which may or may not contain a non-null value, helping to avoid NullPointerException.

Example:

Optional<String> name = Optional.ofNullable(getName());
name.ifPresent(System.out::println);

Explanation: The ifPresent() method checks if a value is present in the Optional and then prints it.

Default Methods

Default methods allow interfaces to have method implementations, which helps in extending interfaces without breaking existing implementations.

Example:

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

class MyClass implements MyInterface {}

MyClass obj = new MyClass();
obj.defaultMethod();

Explanation: The MyInterface interface has a default method that is automatically available in MyClass.

Method References

Method references provide a shorthand for lambda expressions that simply call an existing method.

Example:

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

Explanation: The method reference System.out::println is a concise way to print each element in the list.

Date and Time API (java.time)

The new Date and Time API provides a more robust and flexible way to handle dates and times in Java.

Example:

LocalDate today = LocalDate.now();
LocalDate birthday = LocalDate.of(1990, Month.JANUARY, 1);
Period age = Period.between(birthday, today);
System.out.println("You are " + age.getYears() + " years old.");

Explanation: The LocalDate and Period classes are part of the new API, providing clear and concise date manipulation.

Collectors

The Collectors utility class provides various methods to accumulate elements from a stream into collections or other forms.

Example:

List<String> names = Arrays.asList("John", "Jane", "Jack");
String result = names.stream()
                     .collect(Collectors.joining(", "));
System.out.println(result);

Explanation: The Collectors.joining() method concatenates the stream elements into a single string separated by commas.

Parallel Streams

Parallel streams divide the provided task into multiple sub-tasks and process them in parallel.

Example:

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

Explanation: The parallelStream() method processes the elements of the list in parallel, potentially improving performance.

Conclusion

Java 8 introduced a variety of powerful features that enhance the language's ability to write more expressive, maintainable, and efficient code. This cheat sheet provides a quick reference to the most important features of Java 8, helping you leverage them effectively in your projects. Keep this guide handy as you work with Java 8 to make the most of its capabilities. Happy coding!