1. Wprowadzenie
Method reference (po polsku — referencja do metody) to specjalna składnia w Javie, pozwalająca przekazać już istniejącą metodę (lub konstruktor) jako implementację interfejsu funkcyjnego. Metodę można „przekazać” tam, gdzie oczekuje się wyrażenia lambda, jeśli sygnatury się zgadzają.
Składnia:
Klasa::metoda
obiekt::metoda
Klasa::new
Jeśli lambda to mini-funkcja „w locie”, to method reference to po prostu „przekaż już istniejącą metodę”. To jak wtedy, gdy zamiast przepisywać przepis, podajesz link do strony z przepisem.
Przykład na palcach
Zamiast tego:
list.forEach(s -> System.out.println(s));
Można tak:
list.forEach(System.out::println);
Wygląda zwięźle, prawda?
2. Rodzaje referencji do metod
Referencje do metod mają cztery podstawowe formy. Oto one — i nic więcej nie jest potrzebne.
Referencja do metody statycznej
Składnia: Klasa::statycznaMetoda
Przykład:
Function<Integer, String> intToString = String::valueOf;
System.out.println(intToString.apply(123)); // "123"
To samo za pomocą lambdy:
Function<Integer, String> intToString = i -> String.valueOf(i);
Referencja do niestatycznej metody obiektu
Składnia: obiekt::metoda
Przykład:
PrintStream printer = System.out;
Consumer<String> consumer = printer::println;
consumer.accept("Witaj, świecie!");
Równoważne lambdzie:
Consumer<String> consumer = s -> printer.println(s);
Referencja do niestatycznej metody klasy
Składnia: Klasa::metoda
Tutaj pierwszy parametr interfejsu funkcyjnego staje się obiektem, na którym wywoływana jest metoda.
Przykład:
Function<String, Integer> stringLength = String::length;
System.out.println(stringLength.apply("Java")); // 4
Tutaj String::length zamienia się w funkcję: (String s) -> s.length()
Referencja do konstruktora
Składnia: Klasa::new
Przykład:
Supplier<ArrayList<String>> listSupplier = ArrayList::new;
ArrayList<String> list = listSupplier.get();
Równoważne lambdzie:
Supplier<ArrayList<String>> listSupplier = () -> new ArrayList<>();
3. Kiedy używać referencji do metod?
Referencje do metod warto stosować, gdy lambda tylko wywołuje istniejącą metodę bez dodatkowej logiki — kod staje się wówczas krótszy i bardziej czytelny.
Przykład: sortowanie listy
Zamiast tego:
List<String> names = Arrays.asList("Jan", "Piotr", "Anna");
names.sort((a, b) -> a.compareToIgnoreCase(b));
Można tak:
names.sort(String::compareToIgnoreCase);
Przykład: przetwarzanie kolekcji
Zamiast:
list.forEach(s -> System.out.println(s));
Można jeszcze krócej:
list.forEach(System.out::println);
Przykład: przekształcanie elementów
Zamiast:
List<String> numbers = Arrays.asList("1", "2", "3");
List<Integer> ints = numbers.stream()
.map(s -> Integer.parseInt(s))
.collect(Collectors.toList());
Można:
List<Integer> ints = numbers.stream()
.map(Integer::parseInt)
.collect(Collectors.toList());
Więcej o Stream API i klasie narzędziowej Collectors poznasz na poziomie 30 :P
4. Porównanie referencji do metod i wyrażeń lambda
Równoważność
Referencja do metody i wyrażenie lambda często są wymienne. Oba realizują interfejs funkcyjny, jeśli sygnatury się zgadzają.
Przykład:
Consumer<String> c1 = s -> System.out.println(s);
Consumer<String> c2 = System.out::println;
Kiedy lepiej używać referencji do metod?
- Gdy lambda tylko wywołuje istniejącą metodę bez dodatkowej logiki.
- Dla poprawy czytelności, szczególnie przy długich łańcuchach wywołań.
- Gdy chcesz wyraźnie pokazać: „tu jest tylko wywołanie metody”.
Kiedy referencja do metody nie pasuje?
- Gdy potrzebna jest dodatkowa logika (walidacja, warunki, obsługa błędów).
- Gdy parametry trzeba przekształcić przed wywołaniem metody.
Przykład:
list.forEach(s -> {
if (s != null) System.out.println(s);
});
// Tutaj referencja do metody się nie sprawdzi, tylko lambda.
5. Praktyka: przepisujemy wyrażenia lambda z użyciem referencji do metod
Przykład 1: Wypisujemy nazwy zwierząt
List<String> animals = Arrays.asList("Kot", "Pies", "Papuga");
animals.forEach(animal -> System.out.println(animal));
Po zmianie:
animals.forEach(System.out::println);
Przykład 2: Przekształcamy napisy na liczby
List<String> numbers = Arrays.asList("10", "20", "30");
List<Integer> ints = numbers.stream()
.map(s -> Integer.parseInt(s))
.collect(Collectors.toList());
Po zmianie:
List<Integer> ints = numbers.stream()
.map(Integer::parseInt)
.collect(Collectors.toList());
Przykład 3: Sortowanie obiektów po nazwie
List<Animal> animalList = ...;
animalList.sort((a, b) -> a.getName().compareTo(b.getName()));
Po zmianie:
animalList.sort(Comparator.comparing(Animal::getName));
Tutaj Animal::getName — referencja do niestatycznej metody klasy.
Przykład 4: Tworzenie obiektów przez konstruktor
Supplier<Dog> dogFactory = () -> new Dog();
Dog dog = dogFactory.get();
Po zmianie:
Supplier<Dog> dogFactory = Dog::new;
Dog dog = dogFactory.get();
6. Jak działa dopasowanie sygnatur
Referencję do metody można wykorzystać tylko wtedy, gdy sygnatura metody pokrywa się z metodą abstrakcyjną interfejsu funkcyjnego.
@FunctionalInterface
interface IntToString {
String convert(int value);
}
public class Demo {
public static String intToHex(int value) {
return Integer.toHexString(value);
}
public static void main(String[] args) {
IntToString converter = Demo::intToHex;
System.out.println(converter.convert(255)); // ff
}
}
Tutaj Demo::intToHex pasuje, ponieważ przyjmuje int i zwraca String.
7. Referencje do metod a konstruktory z parametrami
Jeśli konstruktor przyjmuje parametry, referencji do metody nadal można użyć — o ile sygnatury się zgadzają.
@FunctionalInterface
interface AnimalFactory {
Animal create(String name);
}
class Animal {
private String name;
public Animal(String name) { this.name = name; }
public String getName() { return name; }
}
AnimalFactory factory = Animal::new;
Animal cat = factory.create("Whity");
System.out.println(cat.getName()); // Whity
8. Typowe błędy przy użyciu referencji do metod
Błąd nr 1: Niezgodność sygnatur.
Jeśli sygnatura metody nie pokrywa się z metodą abstrakcyjną interfejsu, kompilator zgłosi błąd. Na przykład interfejs oczekuje dwóch parametrów, a referencja wskazuje na metodę z jednym parametrem.
Błąd nr 2: Próba użycia referencji do niestatycznej metody klasy bez obiektu.
Gdy używasz formy Klasa::metoda, pierwszy parametr interfejsu staje się obiektem wywołania. Jeśli pomylisz liczbę lub kolejność parametrów — dostaniesz błąd dopasowania.
Błąd nr 3: Użycie referencji do metody tam, gdzie potrzebna jest dodatkowa logika.
Jeśli wymagany jest warunek, logowanie lub obsługa wyjątków — użyj lambdy, a nie referencji do metody.
Błąd nr 4: Referencje do przeciążonych metod.
Jeśli klasa ma kilka metod o tej samej nazwie, kompilator może nie wiedzieć, którą wybrać. Czasem pomaga jawne wskazanie typu interfejsu funkcyjnego.
Błąd nr 5: Użycie referencji do niestatycznej metody bez obiektu.
Na przykład String::toUpperCase działa poprawnie w map, ponieważ pierwszy parametr to sam obiekt String. Ale poza odpowiednim kontekstem, gdzie oczekuje się metody statycznej, doprowadzi to do błędu.
GO TO FULL VERSION