Master Java Method References: Simplify Lambdas with Clean Code

1. Introduction

Many Java developers have seen method references but cannot name or use them; this article explains what they are and how to use them.

2. Use Cases for Method References

Example of generating 10 random integers, taking absolute values, and printing them.

new Random().ints(10)
        .map(i->Math.abs(i))
        .forEach(i -> System.out.println(i));

The code works but can be simplified.

The map method expects an IntUnaryOperator; the lambda i->Math.abs(i) is equivalent to an anonymous class implementing IntUnaryOperator with applyAsInt returning Math.abs(operand).

new IntUnaryOperator() {
    @Override
    public int applyAsInt(int operand) {
        return Math.abs(operand);
    }
}

Since IntUnaryOperator simply delegates to Math.abs(int i), the lambda can be replaced by a method reference:

new Random().ints(10)
        .map(Math::abs)
        .forEach(System.out::println);

3. Method References

Java method references are a new feature introduced in Java 8 alongside lambda expressions. They allow direct reference to existing class or instance methods or constructors, usually combined with lambdas to simplify code. The condition is that the lambda body contains a single expression that merely calls an existing method with matching parameter list and return type.

Method reference formats:

Static method reference: ClassName::staticMethodName (e.g., Math::abs)

Constructor reference: ClassName::new (e.g., using Supplier<T> to create new instances)

Class instance method reference: ClassName::instanceMethodName (e.g., String::concat)

Specific instance method reference: instance::instanceMethodName (e.g., this::equals)

4. Readability Considerations

Although some think lambdas are hard to read, their pipeline structure can improve readability. Method references make the executed strategy clearer. An example of a “fat” lambda is shown, which is discouraged; instead, encapsulate the logic in a separate method and use a method reference.

new Random().ints(10)
        .map(this::selfIncreasing)
        .forEach(System.out::println);

private int selfIncreasing(int self) {
    System.out.println("self = " + self);
    return self + 1;
}

This version is more readable: it generates 10 numbers, applies a self‑increment method, and prints each.

5. Conclusion

Method references provide a concise alternative to lambda expressions in appropriate scenarios, making code shorter and clearer. Developers accustomed to traditional Java may need time to adapt, and this article aims to help bridge that gap.