Java 8 Features Explained with Suitable Examples

Java has always been a powerful and widely-used programming language, but with the release of Java 8 in March 2014, it underwent one of the most transformative upgrades in its history.

This version didn’t just patch a few things or add minor improvements—it redefined how developers think about writing Java code.

With the introduction of lambda expressions, Stream API, functional interfaces, and the new Date and Time API, Java 8 brought a modern, functional programming twist to the traditionally object-oriented language.

These features were not only designed to reduce boilerplate code and enhance readability but also to improve performance and enable developers to write more declarative, flexible, and concise programs.

In this blog, we will explain the most impactful Java 8 features clearly and provide hands-on examples.

Let’s dive into the world of Java 8 and see how it changed the game for developers worldwide.

Curious about where Java can take you? Enroll in upGrad's Software Engineering course to unlock career opportunities in software development.

An Overview of Java 8

Java 8 is a major release of the Java programming language and the Java Platform, Standard Edition. Officially launched by Oracle, it marked a significant shift in how Java programming applications are developed.

The release of Java 8 aimed to modernize the language, keeping it competitive with newer languages like Scala, Kotlin, and Python, which were gaining popularity for their expressive syntax and concise constructs.

Java 8 is not just an update; it's a transformation.

Looking to combine your Java skills with data science? Enroll in the Executive Diploma in Data Science & AI by IIIT-B and upGrad to future-proof your career.

Significant Java 8 Features You Shouldn’t Miss

Let's explore the important Java 8 features with examples along with explanations for each.

1. Lambda Expressions

Lambda expressions enable you to write anonymous functions, providing a clear and concise way to represent one-method interfaces (functional interfaces) using an expression.​

Example:

public class Main {
    public static void main(String[] args) {

        // Traditional approach using anonymous inner class
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Running in a thread - traditional way");
            }
        };
        runnable.run();

        // Lambda expression (Java 8+)
        Runnable lambdaRunnable = () -> System.out.println("Running in a thread - using lambda");
        lambdaRunnable.run();
    }
}

Output:

Running in a thread - traditional way  
Running in a thread - using lambda

Explanation:

In this example, we use a lambda expression to simplify the creation of a Runnable that prints a message. The lambda () -> System.out.println("Running in a thread") is a compact way to implement the Runnable interface's run() method, replacing the need for an anonymous inner class.

Take your Java development career to the cloud. Learn CI/CD, Kubernetes, and more with upGrad’s Cloud Computing and DevOps certificate program.

2. Functional Interfaces

A functional interface is an interface that contains only one abstract method. They can have multiple default or static methods. The @FunctionalInterface annotation is used to indicate a functional interface.​

Example:

@FunctionalInterface
interface Greeting {
    void sayHello();
}

public class Main {
    public static void main(String[] args) {
        Greeting greet = () -> System.out.println("Hello from a functional interface!");
        greet.sayHello();
    }
}

Output:

Hello from a functional interface!

Explanation:

The Calculator interface is a functional interface with a single abstract method operation. We use a lambda expression (a, b) -> a + b to implement this method for adding two integers, which is then called to print the result.

3. Method References

Method references provide a way to refer to methods without invoking them. They are compact and readable and can be used with lambda expressions.​

Example:

import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Aparna", "Bunny", "Charu");
        names.forEach(System.out::println); // Method reference
    }
}

Output:

Aparna
Bunny
Charu

Explanation:

A functional interface has only one abstract method, making it suitable for lambda expressions. Here, Greeting is a functional interface, and the lambda provides the implementation for sayHello() method.

4. Stream API

The Stream API provides a functional approach to process sequences of elements (like collections). Streams in Java support operations such as filter, map, and reduce.​

Example:

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Aparna", "Bunny", "Charu");
        names.stream()
             .filter(name -> name.startsWith("A"))
             .forEach(System.out::println);
    }
}

Output:

Aparna

Explanation:

We create a stream from a list of names and use the filter method to select names starting with "A". The forEach method prints each matching name. This demonstrates the power of functional-style operations on collections with the Stream API.

5. Optional Class

The Optional class is a container object used to represent the presence or absence of a value. It helps to avoid null pointer exceptions and makes the code more readable and maintainable.​

Example:

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optional = Optional.of("Hello, Optional!");
        optional.ifPresent(System.out::println);

        Optional<String> emptyOptional = Optional.empty();
        System.out.println(emptyOptional.orElse("Default Value"));
    }
}

Output:

Hello, Optional!
Default Value

Explanation:

We create an Optional object containing a string and use ifPresent to print the value if present. We also demonstrate Optional.empty() and orElse to provide a default value when the Optional is empty, showcasing how Optional helps avoid NullPointerException.

6. New Date and Time API

Java 8 introduced a new date and time API under the java.time package, which is more comprehensive and consistent than the old java.util.Date and java.util.Calendar classes.​

Example:

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;

public class DateTimeExample {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        LocalTime time = LocalTime.now();
        LocalDateTime dateTime = LocalDateTime.now();
        ZonedDateTime zonedDateTime = ZonedDateTime.now();

        System.out.println("Date: " + date);
        System.out.println("Time: " + time);
        System.out.println("DateTime: " + dateTime);
        System.out.println("ZonedDateTime: " + zonedDateTime);
    }
}

Output:

Date: 2025-04-20
Time: 18:35:10.230890187
DateTime: 2025-04-20T18:35:10.230981418
ZonedDateTime: 2025-04-20T18:35:10.231460578Z[GMT]

Explanation:

This example shows how to use the new java.time API to obtain the current date, time, date-time, and zoned date-time, demonstrating the more intuitive and immutable date and time handling introduced in Java 8.

7. Default and Static Methods in Interfaces

Prior to Java 8, interfaces could only have public and abstract methods. Starting with Java 8, they can also have default and statics methods. Default methods help to keep code backwards compatible when new methods are added to an interface. Static methods allow having utility code within interfaces.​

Example:

interface MyInterface {
    default void defaultMethod() {
        System.out.println("Default method!");
    }

    static void staticMethod() {
        System.out.println("Static method!");
    }
}

public class InterfaceExample implements MyInterface {
    public static void main(String[] args) {
        InterfaceExample example = new InterfaceExample();
        example.defaultMethod();
        MyInterface.staticMethod();
    }
}

Output:

Default method!
Static method!

Explanation:

The example demonstrates how Java 8 allows interfaces to have both default and static methods. The defaultMethod provides a default implementation that can be used by implementing classes, while staticMethod is called directly from the interface.

8. Base64 Encoding and Decoding

Java 8 introduced built-in support for Base64 encoding and decoding in the java.util.Base64 class. Prior to Java 8, developers relied on third-party libraries or custom implementations.

Example:

import java.util.Base64;
public class Base64Example {
    public static void main(String[] args) {
        String original = "Java 8 Rocks!";
        // Encode
        String encoded = Base64.getEncoder().encodeToString(original.getBytes());
        System.out.println("Encoded: " + encoded);
        // Decode
        String decoded = new String(Base64.getDecoder().decode(encoded));
        System.out.println("Decoded: " + decoded);
    }
}

Output:

Encoded: SmF2YSA4IFJvY2tzIQ==
Decoded: Java 8 Rocks!

Explanation:

Here, we use Java 8’s Base64 utility to encode a string into its Base64 representation and then decode it back to the original string. This is useful for encoding binary data or text for secure transmission over networks.

9. Nashorn JavaScript Engine

Java 8 includes the Nashorn JavaScript engine, which allows embedding JavaScript code within Java applications. This replaces the older Rhino engine and brings better performance and ECMAScript compliance.

Example:

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class NashornExample {
    public static void main(String[] args) throws Exception {
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
        engine.eval("print('Hello from JavaScript in Java 8!')");
    }
}

Output:

Hello from JavaScript in Java 8!

Explanation:

This example demonstrates how Java 8’s Nashorn engine allows embedding JavaScript code within a Java application, enabling dynamic scripting within a statically typed language, making it suitable for scenarios like rule engines or template systems.

Final Thoughts

In summary, Java 8 brought transformative features that have made it a milestone in the Java ecosystem. From simplifying code with lambdas and functional interfaces to offering powerful tools like the Stream API and Optional class, Java 8 has proven its relevance over time.

Even today, many Java developers rely on these features to write more expressive, readable, and performance-optimized code.

These advancements have kept Java competitive and modern, helping developers tackle real-world problems with ease and efficiency. Whether you’re working on new projects or maintaining legacy systems, Java 8’s features are valuable tools that continue to benefit developers worldwide.

FAQs

1. What are the key features introduced in Java 8?

Java 8 introduced several important features such as Lambda Expressions, Stream API, Default Methods in Interfaces, Optional Class, and New Date and Time API. These features were designed to improve code readability, make processing data more efficient, and provide more flexibility for developers.

2. How does Lambda Expression improve Java 8 code?

Lambda expressions allow you to write concise, functional code by eliminating the need for verbose anonymous class implementations. This results in cleaner and more readable code, especially when dealing with collections or functional-style programming tasks.

3. What is the Stream API in Java 8, and how does it enhance performance?

The Stream API allows developers to process sequences of elements (such as collections) in a functional style. It supports operations like filtering, mapping, and reducing, and can work with large datasets more efficiently by utilizing lazy evaluation and parallel processing, leading to improved performance in many scenarios.

4. How do Default Methods in Interfaces benefit developers?

Default methods allow interfaces to have method implementations. This feature enables developers to add new methods to interfaces without breaking existing implementations. It helps in extending interfaces in a backward-compatible manner, especially useful in API evolution.

5. What role does the Optional class play in Java 8?

The Optional class provides a way to avoid NullPointerException by explicitly representing the presence or absence of a value. It encourages better handling of null values by requiring developers to either provide a value or handle the case when no value is present, leading to more robust code.

6. How does Java 8’s Date and Time API differ from previous versions?

The new Date and Time API in Java 8 (located in the java.time package) is more intuitive and flexible. Unlike the old Date and Calendar classes, it is immutable, thread-safe, and provides better handling of dates and times, including time zones, formatting, and parsing.

7. What are the advantages of using Java 8's Method References?

Method references in Java 8 provide a shorthand for using lambda expressions that call a single method. It makes the code more concise and readable. Instead of writing out the full lambda expression, method references allow you to directly refer to methods of existing classes.

8. Can you explain how Java 8's Functional Interfaces enhance value-driven programming?

Functional interfaces are interfaces that have only one abstract method, but they can have multiple default or static methods. Java 8’s functional interfaces provide a foundation for functional programming, allowing for cleaner, more modular, and reusable code. This aligns with the principles of value-driven programming by promoting clear and concise design.

9. How do Lambda Expressions and Stream API work together?

Lambda expressions are used as arguments for Stream API operations, enabling functional-style processing of collections. You can use lambda expressions to filter, transform, and collect data from streams in a very compact and readable way, resulting in more efficient and expressive code.

10. What is the significance of the new java.util.concurrent package introduced in Java 8?

The new java.util.concurrent package in Java 8 introduces features such as CompletableFuture and Stochastic operations that provide better support for asynchronous programming and concurrency. These features improve the scalability and performance of multi-threaded applications, especially in cloud-based or distributed environments.

11. Why should developers adopt Java 8 features for long-term projects?

Adopting Java 8 features brings numerous benefits such as improved code maintainability, better performance, and a more functional programming style. These features allow developers to write cleaner, more concise code that is easier to understand and extend. With continued support and widespread use, Java 8 features provide a long-term, scalable solution for modern software development.

Take the Free Quiz on Java

Answer quick questions and assess your Java knowledge

Start Quiz