Course contentsShow
← Java
Lesson 1751 of 2,87036. Lambda Expressions and Method ReferencesFree lesson

Constructor Reference vs Lambda Equivalents

Compare constructor references to their lambda expression equivalents and understand when each is clearer.

Constructor Reference vs Lambda Equivalents

You'll learn when constructor references are clearer than their lambda equivalents and when lambdas might be preferable.

The Core Difference

Constructor references and lambda expressions can often accomplish the same task. A constructor reference like Person::new is shorthand for a lambda that calls that constructor. Understanding when each form is clearer helps you write more readable code.

Direct Equivalents

When a constructor reference maps directly to a functional interface, both forms are functionally identical:

// Constructor reference
Supplier<Person> personSupplier = Person::new;

// Lambda equivalent
Supplier<Person> personSupplierLambda = () -> new Person();

With parameters:

// Constructor reference
BiFunction<String, Integer, Person> factory = Person::new;

// Lambda equivalent
BiFunction<String, Integer, Person> factoryLambda = 
    (name, age) -> new Person(name, age);

When Constructor References Win

Constructor references shine when you're simply passing arguments through without transformation:

Function<String, Person> byName = Person::new;
// Clearer than: (name) -> new Person(name)

They're particularly clean in Stream operations:

List<String> names = List.of("Alice", "Bob");
List<Person> people = names.stream()
    .map(Person::new)
    .toList();

When Lambdas Win

Use lambdas when you need to:

  • Transform arguments before passing them
  • Call a specific overloaded constructor that's ambiguous
  • Perform additional logic beyond construction
// Adding logic: lambda is clearer
Function<String, Person> normalized = 
    name -> new Person(name.trim().toLowerCase());

Key Takeaway: Constructor references are clearer when directly mapping arguments to constructors; use lambdas when you need additional logic or when the constructor call isn't straightforward.