Search⌘ K
AI Features
Home
Courses
Modern Java: From Fundamentals to Advanced Architecture

Lambda Expressions

Explore how lambda expressions replace verbose anonymous classes in Java, enabling concise and readable behavior passing through functional interfaces like Comparator and Runnable. Understand lambda syntax, type inference, and functional interfaces to write clean, efficient Java code following modern functional programming principles.

We'll cover the following...

Java allows us to pass behavior, such as a sorting rule or a task for a thread, through interfaces. Before lambda expressions, doing this required verbose anonymous classes, even for very small pieces of logic.

Lambda expressions reduce this overhead by letting us supply behavior directly while preserving Java’s type safety. This lesson explains how to write lambdas, how the compiler interprets them, and the syntax rules that keep code readable.

The boilerplate of anonymous classes

Before lambdas arrived, passing a block of code to a method required an anonymous inner class. This approach worked, but it was noisy. We had to declare a class, instantiate it, and override a method, even if we only needed a single line of logic.

Let’s look at how we traditionally sorted a list of strings by their length. We had to create a Comparator object and override its compare method.

Java 25
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class OldStyleSort {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        // Old way: Anonymous Inner Class
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return Integer.compare(s1.length(), s2.length());
            }
        });
        System.out.println(names);
    }
}

  • Line 14: We instantiate an anonymous implementation of Comparator.

  • Line 16: We explicitly write the method signature for compare, repeating the ...