In Java, method references are a shorthand notation for calling methods using the functionality of functional programming. Since the introduction of Java 8, the language has supported method references, providing a more readable and compact syntax than traditional lambda expressions. With method references, you can refer to a method of a class or instance, allowing cleaner code when working with collections, especially when paired with the Stream API.
What Are Method References?
Method references provide a way to refer to methods (both static and instance) by their names without invoking them. The general syntax for a method reference is:
ClassName::methodName
There are four types of method references in Java:
- Static method reference: Refers to static methods of a class.
- Instance method reference on a particular object: Refers to instance methods of a specific object.
- Instance method reference on an arbitrary object of a particular type: Refers to instance methods of an object from a class type.
- Constructor reference: Refers to the constructor of a class.
Using Method References with Java Collections
In this section, we will explore how to use method references effectively with collections, especially using Java 8’s Stream API, which is a powerful feature for processing collections of objects.
Example 1: Using Method References with a List
Let’s start with a simple example where we use method references to print elements of a list using a static method.
import java.util.Arrays;
import java.util.List;
public class MethodReferenceExample {
public static void printMessage(String message) {
System.out.println(message);
}
public static void main(String[] args) {
List messages = Arrays.asList("Hello", "World", "Java");
// Using method reference to print each message
messages.forEach(MethodReferenceExample::printMessage); // static method reference
}
}
In the code above, we have a list of strings. We use the forEach() method of the List class to print each message, using a method reference MethodReferenceExample::printMessage to refer to the static method printMessage.
Example 2: Using Method References with Instance Methods
Now, let’s look at how we can use method references with instance methods. In this case, we will define an object and refer to its method using a method reference.
import java.util.Arrays;
import java.util.List;
public class MethodReferenceExample {
public void printMessage(String message) {
System.out.println(message);
}
public static void main(String[] args) {
MethodReferenceExample example = new MethodReferenceExample();
List messages = Arrays.asList("Hello", "World", "Java");
// Using method reference to call instance method
messages.forEach(example::printMessage); // instance method reference
}
}
In this example, we use an instance method reference example::printMessage to refer to the method of the MethodReferenceExample class. The method printMessage is invoked for each element in the list.
Example 3: Using Method References with Stream API
One of the most powerful ways to use method references with collections is through the Stream API. The Stream API allows us to process elements of a collection in a functional style, applying methods such as filtering, mapping, and reducing.
import java.util.Arrays;
import java.util.List;
public class MethodReferenceExample {
public static void main(String[] args) {
List names = Arrays.asList("John", "Jane", "Alex", "Mike");
// Using method reference with Stream API to print each name
names.stream().forEach(System.out::println); // static method reference
}
}
In this example, we use the Stream API to create a stream from a list of names and then apply the forEach() method to print each name. We use the method reference System.out::println to refer to the static println method of the System.out object.
Example 4: Using Method References with Collection Transformation
In this example, we demonstrate how to transform a collection using method references. We will use the map() method from the Stream API to convert a list of strings into their uppercase equivalents using a method reference.
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class MethodReferenceExample {
public static String toUpperCase(String input) {
return input.toUpperCase();
}
public static void main(String[] args) {
List names = Arrays.asList("john", "jane", "alex", "mike");
// Using method reference to convert strings to uppercase
List upperCaseNames = names.stream()
.map(MethodReferenceExample::toUpperCase)
.collect(Collectors.toList());
upperCaseNames.forEach(System.out::println);
}
}
In this case, we use the method reference MethodReferenceExample::toUpperCase to convert each string in the list to uppercase. This is done within the map() operation of the stream.
Advantages of Using Method References with Collections
Using method references with collections offers several advantages:
- Concise syntax: Method references provide a cleaner and more concise way to write code compared to traditional lambda expressions.
- Improved readability: Method references are easier to read, especially when working with collection operations.
- Reusability: You can reuse existing methods, reducing the need to write new lambda expressions.
Conclusion
Method references are an essential feature introduced in Java 8 that simplifies your code, especially when working with collections and the Stream API. By understanding the different types of method references and applying them with the Java Collections Framework, you can write more efficient, readable, and maintainable code. Try incorporating method references into your own Java projects to see the benefits firsthand.
