Java 8, released in 2014, is the single most significant release in the language's history — more production code targets Java 8's baseline today than any other version, and nearly everything covered elsewhere in this series, lambda expressions, the Stream API, Optional, the modern Date and Time API, method references, arrived in this one release. What changed wasn't a single feature added to an already-complete language; it was Java's entire default style of writing everyday code, shifting from loops and mutable state toward expressions and immutable values.

What Changed in Java 8?

Feature	What It Solves
Lambda expressions	Removes anonymous-class boilerplate for implementing single-method interfaces
Functional interfaces	Formalizes the single-abstract-method contract lambdas target
Stream API	Replaces manual loops with declarative filter, map, and collect pipelines
Method references	Shortens lambdas that only forward to an existing method
Optional	Makes "this might not have a value" explicit in a return type
Default and static interface methods	Lets an interface gain new methods without breaking existing implementers
New Date and Time API (java.time)	Replaces the mutable, thread-unsafe Date and Calendar classes
Base64 API	Adds encoding and decoding directly to the JDK, with no external library needed
Nashorn JavaScript engine	Ships a JavaScript engine directly inside the JVM (deprecated in Java 11, removed in Java 15)
CompletableFuture	Adds composable, callback-driven asynchronous programming to java.util.concurrent

Why Java 8 Was a Turning Point

The shift is visible in the smallest possible example — passing behavior into a method used to mean writing an entire anonymous class just to supply one method body.

Before Java 8:                          After Java 8:

new Comparator<String>() {              (a, b) -> a.compareTo(b)
    public int compare(String a,
                        String b) {
        return a.compareTo(b);
    }
}

Six lines of ceremony collapse into one expression that says exactly what it does and nothing else — this single shift in how behavior gets passed around is what the rest of Java 8 builds on.

Interview tip: when asked to list Java 8 features, group them into three buckets instead of reciting a flat list — syntax (lambdas, method references), API (Streams, Optional), and infrastructure (java.time, Base64). Interviewers notice organized thinking faster than a longer list.

Filtering a list and summing a condition used to mean a loop with an accumulator variable, tracked and mutated by hand across every iteration.

Java

Try it out

// File: BeforeJava8.java
import java.util.*;

public class BeforeJava8 {
    record Order(String category, double amount) {}

    public static void main(String[] args) {
        List<Order> orders = List.of(
            new Order("Electronics", 799.0),
            new Order("Books", 450.0),
            new Order("Electronics", 1499.0)
        );

        double total = 0;
        for (Order order : orders) {
            if (order.category().equals("Electronics")) {
                total += order.amount();
            }
        }

        System.out.println("Electronics total: " + total);
    }
}

Output:
Electronics total: 2298.0

The same calculation as a stream pipeline reads as a description of the result, with lambdas and method references doing the work the loop and accumulator used to.

Java

Try it out

// File: AfterJava8.java
import java.util.*;
import java.util.stream.*;

public class AfterJava8 {
    record Order(String category, double amount) {}

    public static void main(String[] args) {
        List<Order> orders = List.of(
            new Order("Electronics", 799.0),
            new Order("Books", 450.0),
            new Order("Electronics", 1499.0)
        );

        double total = orders.stream()
            .filter(order -> order.category().equals("Electronics"))
            .mapToDouble(Order::amount)
            .sum();

        System.out.println("Electronics total: " + total);
    }
}

Output:
Electronics total: 2298.0

Both versions compute the same total. The second one has no loop variable or running total for a reader to track by hand.

A Tour of Java 8's Core Features

Lambda Expressions and Functional Interfaces

A lambda implements a functional interface — an interface with exactly one abstract method — inline, without a class declaration. This is the foundation everything else in this list is built on, and it has its own dedicated articles in this series covering syntax, scoping rules, and the built-in Predicate, Function, Consumer, and Supplier interfaces in depth.

Java

Try it out

// File: LambdaQuickLook.java
import java.util.function.*;

public class LambdaQuickLook {
    public static void main(String[] args) {
        Predicate<String> isLongName = name -> name.length() > 5;

        System.out.println(isLongName.test("Ananya"));
    }
}

Output:
true

The Stream API

A stream chains filtering, transforming, and collecting operations into one declarative pipeline over a collection, covered across its own dedicated series of articles for each operation.

Java

Try it out

// File: StreamQuickLook.java
import java.util.*;
import java.util.stream.*;

public class StreamQuickLook {
    public static void main(String[] args) {
        List<String> names = List.of("Rohit", "Ananya", "Vikram");

        List<String> upperCaseNames = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());

        System.out.println(upperCaseNames);
    }
}

Output:
[ROHIT, ANANYA, VIKRAM]

Optional

Optional puts "this might not have a value" directly into a method's return type, replacing a null a caller might forget to check.

Java

Try it out

// File: OptionalQuickLook.java
import java.util.*;

public class OptionalQuickLook {
    public static void main(String[] args) {
        Optional<String> maybeName = Optional.ofNullable(null);

        System.out.println(maybeName.orElse("Unknown"));
    }
}

Output:
Unknown

Default and Static Methods in Interfaces

Before Java 8, adding a new method to an interface broke every class that already implemented it, since implementing an interface has always meant providing every one of its methods. A default method carries its own body, so existing implementers inherit it automatically without needing to change anything — this is exactly how the JDK added forEach() to Iterable and stream() to Collection without breaking the enormous number of classes that already implemented them.

Java

Try it out

// File: DefaultMethodExample.java

public class DefaultMethodExample {

    interface Vehicle {
        String getName();

        // Default method - existing implementers get this for free,
        // without needing to implement it themselves
        default void honk() {
            System.out.println(getName() + " says: Beep beep!");
        }

        // Static method - belongs to the interface itself, not to
        // any particular implementation
        static Vehicle basic(String name) {
            return () -> name;
        }
    }

    static class ElectricCar implements Vehicle {
        public String getName() { return "Electric Car"; }

        // Overriding the default is optional, not required
        @Override
        public void honk() {
            System.out.println(getName() + " says: Silent beep");
        }
    }

    public static void main(String[] args) {
        Vehicle genericVehicle = Vehicle.basic("Bicycle");
        genericVehicle.honk();

        Vehicle electricCar = new ElectricCar();
        electricCar.honk();
    }
}

Output:
Bicycle says: Beep beep!
Electric Car says: Silent beep

genericVehicle is built from a lambda and never overrides honk(), so it falls back to the interface's own default implementation. electricCar overrides it explicitly, and its own version runs instead — default methods provide a fallback, not a fixed, unchangeable behavior.

The New Date and Time API

java.time replaces the mutable, thread-unsafe Date and Calendar classes with immutable, purpose-built types — LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Period, Duration, and DateTimeFormatter, each covered in its own dedicated article in this series.

Java

Try it out

// File: DateTimeQuickLook.java
import java.time.*;

public class DateTimeQuickLook {
    public static void main(String[] args) {
        LocalDate today = LocalDate.of(2026, 8, 25);
        LocalDate nextWeek = today.plusWeeks(1);

        System.out.println(nextWeek);
    }
}

Output:
2026-09-01

Method References

A method reference points directly at an existing method, replacing a lambda whose only job is to forward its arguments into that method.

Java

Try it out

// File: MethodReferenceQuickLook.java
import java.util.*;

public class MethodReferenceQuickLook {
    public static void main(String[] args) {
        List<String> names = List.of("Rohit", "Ananya", "Vikram");

        names.forEach(System.out::println);
    }
}

Output:
Rohit
Ananya
Vikram

The Base64 API

Before Java 8, encoding or decoding Base64 meant relying on the unsupported, internal sun.misc.BASE64Encoder class, or pulling in an entire external library for one small utility. java.util.Base64 added a clean, standard, fully documented encoder and decoder directly to the JDK.

Java

Try it out

// File: Base64Example.java
import java.util.*;
import java.nio.charset.*;

public class Base64Example {
    public static void main(String[] args) {
        String original = "DevStackFlow";

        String encoded = Base64.getEncoder().encodeToString(original.getBytes(StandardCharsets.UTF_8));
        byte[] decodedBytes = Base64.getDecoder().decode(encoded);
        String decoded = new String(decodedBytes, StandardCharsets.UTF_8);

        System.out.println("Original: " + original);
        System.out.println("Encoded length: " + encoded.length());
        System.out.println("Decoded matches original: " + original.equals(decoded));
    }
}

Output:
Original: DevStackFlow
Encoded length: 16
Decoded matches original: true

Real-World Example

A weekly sales report needs to filter transactions down to a specific date range, total them, identify the top seller safely even when no sales exist, and format the header through a pluggable interface — a compact scenario that uses LocalDate, the Stream API, Optional, a lambda-implemented interface, and a default method all in the same few lines.

Java

Try it out

// File: SaleRecord.java
import java.time.*;

public record SaleRecord(String product, double amount, LocalDate saleDate) {}

Java

Try it out

// File: ReportFormatter.java

@FunctionalInterface
public interface ReportFormatter {
    String formatHeader(String title);

    // Default method - shared formatting logic every formatter gets for free
    default String formatCurrency(double amount) {
        return String.format("Rs.%.2f", amount);
    }
}

Java

Try it out

// File: WeeklySalesReport.java
import java.time.*;
import java.util.*;
import java.util.stream.*;

public class WeeklySalesReport {

    public void generate(List<SaleRecord> sales, LocalDate weekStart, LocalDate weekEnd, ReportFormatter formatter) {
        List<SaleRecord> thisWeek = sales.stream()
            .filter(sale -> !sale.saleDate().isBefore(weekStart) && !sale.saleDate().isAfter(weekEnd))
            .collect(Collectors.toList());

        double total = thisWeek.stream()
            .mapToDouble(SaleRecord::amount)
            .sum();

        Optional<SaleRecord> topSale = thisWeek.stream()
            .max(Comparator.comparingDouble(SaleRecord::amount));

        System.out.println(formatter.formatHeader("Weekly Sales Report"));
        System.out.println("Total: " + formatter.formatCurrency(total));
        System.out.println("Top sale: " + topSale
            .map(sale -> sale.product() + " - " + formatter.formatCurrency(sale.amount()))
            .orElse("No sales this week"));
    }
}

Java

Try it out

// File: SalesReportDemo.java
import java.time.*;
import java.util.*;

public class SalesReportDemo {
    public static void main(String[] args) {
        List<SaleRecord> sales = List.of(
            new SaleRecord("Wireless Mouse", 799.0, LocalDate.of(2026, 8, 24)),
            new SaleRecord("Keyboard", 1499.0, LocalDate.of(2026, 8, 26)),
            new SaleRecord("Monitor", 8999.0, LocalDate.of(2026, 8, 20))
        );

        ReportFormatter formatter = title -> "=== " + title + " ===";

        WeeklySalesReport report = new WeeklySalesReport();
        report.generate(sales, LocalDate.of(2026, 8, 23), LocalDate.of(2026, 8, 29), formatter);
    }
}

Output:
=== Weekly Sales Report ===
Total: Rs.2298.00
Top sale: Keyboard - Rs.1499.00

The Monitor sale from August 20th falls outside the requested week and is correctly excluded by the filter() step, leaving only the two in-range sales to total and rank. During code reviews, seniors commonly point to exactly this kind of report generator as the moment Java 8 features stop feeling like separate, disconnected topics and start reading as one coherent style — a date range check, a stream pipeline, an Optional-safe lookup, and a lambda-implemented interface each doing exactly one job, instead of one long method mixing all four concerns together by hand.

Combining Java 8 Features With Each Other

Every feature in this article composes with the others by design — Stream.filter() and map() take a Predicate and a Function, both implemented as lambdas or method references; Stream.max() and similar terminal operations return an Optional to handle the empty case safely; and java.time values flow through stream pipelines exactly like any other object, filtered and compared the same way. The dedicated articles throughout this series on Lambda Expressions, Functional Interfaces, Streams, Optional, and the Date and Time API each go deep into one of these pieces — this article exists to show how naturally they fit together once each one is individually familiar.

Best Practices

Reach for the dedicated article on each feature the moment a real task needs to go past a one-line example — Lambda Expressions, Functional Interfaces, Streams, Optional, and the Date and Time API are each covered in full depth elsewhere in this series.

Use default methods for genuine backward-compatible interface evolution, not as a convenient place to stash shared logic that would fit more naturally in a regular helper class.

Prefer java.time and java.util.Base64 over any pre-Java-8 workaround or third-party dependency that existed solely to fill the gap those two features closed.

Treat Java 8 as the baseline the rest of this Modern Java section builds on — var, switch expressions, and records all assume a reader who is already comfortable with lambdas and streams.

Common Mistakes

Forcing a stream pipeline onto something small enough that a plain expression would be clearer adds setup overhead for no real readability benefit.

Java

Try it out

// File: OverusingStreamsMistake.java
import java.util.*;

public class OverusingStreamsMistake {
    public static void main(String[] args) {
        List<Integer> twoNumbers = List.of(3, 7);

        // WRONG INTENT - forcing a stream pipeline onto two elements adds
        // pipeline setup overhead for no readability benefit at this scale
        int sumViaStream = twoNumbers.stream().mapToInt(Integer::intValue).sum();

        // CORRECT - a plain expression is clearer for something this small
        int sumDirect = twoNumbers.get(0) + twoNumbers.get(1);

        System.out.println("Via stream: " + sumViaStream);
        System.out.println("Direct: " + sumDirect);
    }
}

Output:
Via stream: 10
Direct: 10

Assuming a static interface method behaves like a default method — inherited and overridable by implementing classes — overlooks that static methods belong to the interface itself and are never inherited at all.

Java

Try it out

// File: DefaultVsStaticMistake.java

public class DefaultVsStaticMistake {

    interface Greeter {
        default String greet() { return "Hello from default"; }
        static String staticGreet() { return "Hello from static"; }
    }

    static class CustomGreeter implements Greeter {
        // Overriding a default method works fine
        @Override
        public String greet() { return "Hello from CustomGreeter"; }

        // A static method cannot be overridden - this is a brand new,
        // unrelated static method, not an override of Greeter.staticGreet()
        static String staticGreet() { return "Hello from CustomGreeter's own static method"; }
    }

    public static void main(String[] args) {
        Greeter greeter = new CustomGreeter();
        System.out.println(greeter.greet());

        System.out.println(Greeter.staticGreet());
        System.out.println(CustomGreeter.staticGreet());
    }
}

Output:
Hello from CustomGreeter
Hello from static
Hello from CustomGreeter's own static method

Assuming every Java 8 feature is a strict drop-in replacement with no new behavior of its own is a subtler mistake worth avoiding — Optional is not simply a nullable reference with extra syntax, and a stream pipeline is not automatically faster than an equivalent loop. Each dedicated article in this series covers the specific mistakes that come from treating its feature as a plain syntax upgrade rather than a genuinely different tool.

Interview Questions

Q1. What were the major features introduced in Java 8?

Lambda expressions and functional interfaces, the Stream API, Optional, default and static interface methods, the new java.time Date and Time API, method references, and the java.util.Base64 API, along with CompletableFuture for composable asynchronous programming. Interviewers typically use this as an opening question to see how comprehensively a candidate can list the release's scope before diving into any one feature in depth.

Q2. Why was Java 8 considered such a significant release compared to previous versions?

Earlier releases mostly added individual classes or syntax conveniences, while Java 8 changed the language's default style of writing everyday code — from imperative loops and mutable state toward declarative, functional-style expressions built around lambdas and streams. It also fixed two long-standing, widely felt design problems at once: the awkward, unsafe legacy date API and the boilerplate required to pass behavior as a value. The nuance interviewers listen for here is whether you can name what actually changed structurally, not just recite the feature list.

Q3. What problem do default methods solve, and how did the JDK itself use them?

Default methods let an interface gain a new method with a body, which existing implementing classes inherit automatically without needing any code changes — solving the problem that adding any new method to an interface used to break every class that already implemented it. The JDK used this directly to add forEach() to Iterable and stream() to Collection in Java 8 without breaking the vast number of existing classes across the ecosystem that already implemented those interfaces. Interviewers at product companies often follow up by asking why this couldn't have been solved with abstract classes instead — the answer is that a class can extend only one class but implement many interfaces.

Q4. Can a static method on an interface be overridden by an implementing class?

No. A static method belongs to the interface itself, not to any implementing class, so it is never inherited and cannot be overridden. A class can declare its own static method with the same name and signature, but that is an entirely separate, unrelated method — not a polymorphic override, which is exactly the distinction product-based interviews often probe by asking what happens when both exist.

Q5. What is the relationship between lambda expressions and functional interfaces?

A functional interface defines the contract — the single abstract method's parameter types and return type — and a lambda expression provides an implementation of that contract inline, without a class declaration. A lambda cannot exist without a functional interface as its target type, and understanding this relationship is what makes the rest of java.util.function and the Stream API make sense as a coherent system rather than a list of separate APIs to memorize.

Q6. What existed before java.util.Base64, and why was adding it to the JDK worthwhile?

Before Java 8, encoding or decoding Base64 meant using the unsupported, internal sun.misc.BASE64Encoder and BASE64Decoder classes, which generated compiler warnings and were never part of any official public API, or bringing in an external library like Apache Commons Codec for a task that conceptually belongs in the standard library. java.util.Base64 gave every Java application a clean, documented, dependency-free way to perform an extremely common operation — a smaller question, but service-based interviewers use it to check whether a candidate actually knows the standard library beyond collections and streams.

FAQs

Is Java 8 still supported and widely used today?

Yes. Java 8 remains one of the most widely deployed versions in production, and Oracle and other vendors continue offering extended support for it, which is exactly why so much real-world code — and this article's comparison to legacy alternatives — still matters.

Do I need to learn every Java 8 feature before moving on to Java 11, 17, or 21 features?

A working understanding of lambdas, streams, and Optional is genuinely necessary, since later releases build directly on those foundations — var, switch expressions, and pattern matching all assume familiarity with the functional style Java 8 introduced. Deep expertise in every corner, like the full Base64 API surface, is not required before moving forward.

What is the difference between a default method and an abstract method on the same interface?

An abstract method has no body and must be implemented by every class that implements the interface. A default method has a body and is inherited automatically, with implementation left optional for each implementing class. An interface can freely mix both, exactly as ReportFormatter in this article's real-world example does.

Was the Stream API the only way Java 8 improved working with collections?

No. Beyond streams, Java 8 added default methods like forEach(), removeIf(), and replaceAll() directly to existing collection interfaces, along with new methods on Map like computeIfAbsent() and merge(), all improving everyday collection work without requiring a full stream pipeline for simple cases.

What happened to the Nashorn JavaScript engine mentioned as a Java 8 feature?

Nashorn was deprecated in Java 11 and fully removed in Java 15, since it struggled to keep pace with the rapidly evolving JavaScript language specification and saw limited real-world adoption. It is a genuinely notable piece of Java 8 history, but not something current code should depend on.

Can a class implement two interfaces that both have default methods with the same signature?

Yes, but the compiler forces the implementing class to resolve the conflict explicitly by overriding the method itself, rather than guessing which interface's default should win. Inside that override, the class can call either parent's version directly using InterfaceName.super.methodName().

Is CompletableFuture part of the Stream API?

No. CompletableFuture lives in java.util.concurrent and is part of Java 8's concurrency improvements, used for composing asynchronous operations with callbacks — a genuinely separate feature from the Stream API, even though both were introduced in the same release and both lean heavily on lambdas.

Summary

Java 8 is less a single feature and more the moment Java adopted an entirely different default shape for everyday code — lambdas and functional interfaces gave behavior a way to travel as a value, streams turned loops into declarative pipelines, Optional gave absence a real type, default methods let interfaces evolve safely, and java.time finally replaced a genuinely broken legacy API.

The weekly sales report example above is worth remembering as the shape this all takes in real code: small, focused pieces — a filter, a stream pipeline, an Optional-safe lookup, a lambda-implemented interface — composed together rather than one long method doing everything by hand. Every dedicated article in this series goes deeper into exactly one of these pieces; this one is the map showing how they all fit.

What to Read Next

Continue Learning Modern Java

Next Step

Java 11 Features

Learn what's new in the Java 11 long-term support release.

→

Collectors & groupingBy()

Learn how to group and summarize Stream results.

→

Text Blocks

Learn how to write multi-line strings without messy escaping.

→

Pattern Matching

Learn how to check and cast a type in a single step.

→

←

PreviousLegacy Date vs New API

NextJava 11 Features

→