Java 8 Features Lambda, Streams, Optional

Lambda Expressions and Functional Interfaces

Java 8 features should connect lambda expressions, functional interfaces, streams, Optional, default methods, and method references with practical collection processing.

Connect lambdas and method references to functional interfaces, then use streams, Optional, default methods, and java.time where their contracts improve the code.

A lambda is a compact way to implement a functional interface, which is an interface with one abstract method.

Lambda Example

import java.util.function.Predicate;

public class LambdaDemo {
    public static void main(String[] args) {
        Predicate<String> longName = name -> name.length() > 5;
        System.out.println(longName.test("Java"));
        System.out.println(longName.test("Tutorial"));
    }
}

Streams

Streams process data through operations such as filter, map, sorted, distinct, collect, count, and reduce. They do not store data; they describe a processing pipeline.

Stream Pipeline

import java.util.List;

public class StreamDemo {
    public static void main(String[] args) {
        List<String> names = List.of("Asha", "Ravi", "Meera", "Arun");

        names.stream()
             .filter(name -> name.startsWith("A"))
             .map(String::toUpperCase)
             .forEach(System.out::println);
    }
}

Optional

Optional represents a value that may or may not be present. It helps make absence explicit, especially as a return type.

Optional Example

import java.util.Optional;

public class OptionalDemo {
    static Optional<String> findUserName(int id) {
        return id == 1 ? Optional.of("Asha") : Optional.empty();
    }

    public static void main(String[] args) {
        String name = findUserName(2).orElse("Guest");
        System.out.println(name);
    }
}

Date and Time API

java.time replaced many old Date and Calendar problems with immutable, clearer types such as LocalDate, LocalTime, LocalDateTime, Period, and Duration.

java.time

import java.time.LocalDate;
import java.time.Period;

public class DateTimeDemo {
    public static void main(String[] args) {
        LocalDate birthDate = LocalDate.of(2000, 5, 10);
        LocalDate today = LocalDate.now();
        int age = Period.between(birthDate, today).getYears();
        System.out.println(age);
    }
}

Practical Java 8 Usage

Java 8 made functional-style collection processing common. Lambdas make behavior passable, streams make transformations readable, and Optional helps represent possibly missing results without using raw nulls everywhere.

Use lambda expressions for short behavior.
Use streams for filter-map-reduce style operations.
Use Optional as a return type when a result may be absent.
Avoid streams when a simple loop is clearer.

Using Java 8 features to write clearer collection code

Java 8 introduced features that changed everyday Java style: lambda expressions, streams, functional interfaces, default methods, Optional, and the java.time API. The biggest beginner shift is learning to describe what transformation is needed instead of manually writing every loop step for collection processing.

Streams are powerful when filtering, mapping, sorting, and collecting data, but they should remain readable. A long chain with hidden side effects is harder to debug than a simple loop. Optional is useful for expressing possibly missing values, but it should not be used as a replacement for every null check or as a field type without thought.

Use lambdas for short behavior passed into methods.
Use streams for readable collection pipelines.
Use java.time instead of old Date and Calendar APIs.
Keep stream operations side-effect free where possible.

Filter and transform names with a stream

List<String> names = List.of("Asha", "Ravi", "Anil");
List<String> result = names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .toList();

Before you move on