	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Java 8 Features > Stream API > Method References

Method References

Author: Venkata Sudhakar

Method references are a shorthand notation of a lambda expression that calls a method. They make code cleaner and more readable when a lambda expression simply calls an existing method.

Types of Method References:

1. Static method: ClassName::staticMethod

2. Instance method of a particular object: object::instanceMethod

3. Instance method of an arbitrary object: ClassName::instanceMethod

4. Constructor reference: ClassName::new

The below example shows all four types of method references in Java 8.

import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodReferenceExample {

static int doubleIt(int n) { return n * 2; }

static class Person {
        private String name;
        Person(String name) { this.name = name; }
        String getName() { return name; }
        void printGreeting() { System.out.println("Hello, I am " + name); }
    }

public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// 1. Static method reference: ClassName::staticMethod
        System.out.println("Doubled (static method ref):");
        numbers.stream().map(MethodReferenceExample::doubleIt).forEach(System.out::println);

// 2. Instance method of particular object: instance::method
        String prefix = "Hello, ";
        Function<String, String> greeter = prefix::concat;
        System.out.println("\nGreetings:");
        names.stream().map(greeter).forEach(System.out::println);

// 3. Instance method of arbitrary object: ClassName::method
        System.out.println("\nUppercase (arbitrary object method ref):");
        names.stream().map(String::toUpperCase).forEach(System.out::println);

// 4. Constructor reference: ClassName::new
        Function<String, Person> personFactory = Person::new;
        System.out.println("\nPerson objects (constructor ref):");
        names.stream().map(personFactory).map(Person::getName).forEach(System.out::println);

// 5. System.out::println is also an instance method reference
        System.out.println("\nPrint via method ref:");
        names.forEach(System.out::println);
    }
}

It gives the following output,

Doubled (static method ref):
2
4
6
8
10

Greetings:
Hello, Alice
Hello, Bob
Hello, Charlie

Uppercase (arbitrary object method ref):
ALICE
BOB
CHARLIE

Person objects (constructor ref):
Alice
Bob
Charlie

Print via method ref:
Alice
Bob
Charlie

When to use Method References vs Lambda:

Use method references when the lambda body simply calls a single existing method. They are more concise and improve readability. Use lambdas when you need additional logic or transformations around the method call.

Send your comments, suggestions or queries regarding this site to [email protected].