Java 8 Features Made Simple: A Quick Guide

Java 8 introduced powerful new features that have transformed how we write Java code, making it more efficient, expressive, and functional. In this blog, we’ll see few key features of Java 8, including lambdas, the Stream API and more. Whether you’re a beginner or an experienced developer, this guide will help you understand and leverage these updates to write cleaner, concise code.

Lambda Expressions λ

Lambda expressions are simple block of code which takes in parameter/s and return a value. They are similar to functions but they don't need a name and can be implemented in right in the body of a method. Lambda expressions are primarily used to implement functional interfaces, eliminating lengthy boilerplate code and strengthening readability.

Without Lambda Expressions

With Lambda Expressions

Functional Interfaces

A functional interface in Java is simply an interface with just one job — it has only one abstract method (a method without a body). Think of it as a blueprint for a single task

For example, if you had a functional interface called Printable, it might have one method, print, which defines how to print a text without specifying the details. When you want to use it, you just provide the details of what print should actually do (printing to console or writing to file).

Method References

Method references in Java 8 are like shortcuts that make your code cleaner and easier to read. Imagine you want to tell Java to run a specific method, but without actually calling it directly. Instead of writing out a full command, you can point to it with a "reference," which is kind of like an address pointing to the method.

Let's break down the main types of method references and how they work with examples:

1) Reference to a Static Method

Here, Test::displayMessage points to displayMessage method of Test class, which prints the content to console. It’s a shorthand, and Java knows to run Test.displayMessage() when you use print method

2) Reference to an Instance Method

Here, testObj::displayMessage points to displayMessage method of testObj object of Test class, which prints the content to console. It’s a shorthand, and Java knows to run testObj.displayMessage() when you use print method

3) Reference to Constructor

Here, Message::new is a constructor reference that matches the print(String msg) method of the Printable interface. When printable.print(...) is called, it triggers the constructor of the Message class with the provided message as an argument.

Stream API

The Stream API in Java 8 is a way to handle collections (like lists, sets, or arrays) more efficiently. Think of a stream as a series of data items that you can process one by one, without needing to change the original data. It’s especially useful when you want to filter, sort, or transform data in a list or collection.

A stream is like a “pipeline” that lets data pass through and be processed step-by-step. Imagine you have a list of words, and you want to find all words that start with “J”, make them uppercase, and then print them. A stream will let you do this in a few lines, without writing long loops.

Types of Stream Operations

• Intermediate operations (like filter, map, and sorted) don’t produce results right away but return a modified stream.
• Terminal operations (like forEach, collect, and reduce) produce the final result and end the stream.

Optional

In Java, if you try to use an object that’s null, you get a NullPointerException. This is one of the most common causes of errors in Java. Optional helps to avoid these errors by making it clear when a value might be absent. Instead of directly dealing with null, you work with an Optional object that either contains a value or is empty.

Here’s what’s happening:

• .isPresent() checks if there’s a value inside.
• .get() retrieves the value, but only if there’s one present, Throws NoSuchElementException - if no value is present

Default Methods

Before Java 8, if you wanted to add a new method to an interface, all the classes that implemented that interface had to provide their own version of that method. This could be a hassle, especially if you had a lot of classes. With default methods, you can add new methods to an interface without breaking existing code. Classes that implement the interface can simply use the default method as-is or choose to override it with their own version.

In the main method, we create an instance of InnerTest and call print on it, This will invoke the overridden print method in InnerTest, Since InnerTest2 did not override the print method, it will use the default implementation from the Printable interface

Output:
InnerTest:Hi, Welcome to the World of Java
Default Method: Hi, Welcome to the World of Java