1. Błędy z wyrażeniami lambda: przechwytywanie zmiennych
W Javie wyrażenia lambda mogą używać zmiennych z kontekstu zewnętrznego. Jednak istnieje ograniczenie: takie zmienne muszą być final lub „efektywnie finalne” (effectively final), czyli nie mogą się zmieniać po inicjalizacji.
Przykład błędu
int sum = 0;
List<Integer> list = List.of(1, 2, 3, 4, 5);
list.forEach(n -> sum += n); // Błąd kompilacji!
Dlaczego?
Kompilator zgłasza błąd: zmienna jest używana w lambdzie, więc musi być final lub effectively final, a sum jest modyfikowana wewnątrz lambdy.
Jak tego uniknąć?
- Używaj operacji terminalnych strumieni, które nie wymagają zewnętrznych zmiennych: mapToInt + sum().
- W skrajnych przypadkach — kontenery typu AtomicInteger lub tablica jednoelementowa (ale to raczej hack).
int sum = list.stream().mapToInt(Integer::intValue).sum();
Analogia
Wyobraź sobie, że lambda to „podróżnik w czasie”: „zapamiętuje” wartość zmiennej w momencie utworzenia i nie może obserwować jej dalszych zmian. Próba modyfikacji to „paradoks dziadka” — kompilator nie pozwoli zbudować programu.
2. Błędy z zakresem widoczności i this
W wyrażeniu lambda słowo kluczowe this odnosi się do obiektu zewnętrznego, a nie do klasy anonimowej (jak byłoby w przypadku klas anonimowych).
Przykład
public class Example {
int value = 42;
void foo() {
Runnable r = () -> {
System.out.println(this.value); // this — to Example, a nie Runnable!
};
r.run();
}
}
Ważne: przy przepisywaniu kodu z klas anonimowych na lambdy zmienia się logika działania this — weź to pod uwagę, aby nie uzyskać nieoczekiwanego rezultatu.
3. Problemy ze zmiennym stanem (efekty uboczne)
Podejście funkcyjne zaleca brak efektów ubocznych: funkcje nie zmieniają stanu poza sobą i nie mutują zewnętrznych kolekcji/zmiennych.
List<String> names = new ArrayList<>(List.of("Anna", "Borys", "Wika"));
List<String> newNames = new ArrayList<>();
names.forEach(name -> {
if (name.startsWith("A")) {
newNames.add(name); // Efekt uboczny!
}
});
Kod „działa”, ale jest mniej przewidywalny i niebezpieczny przy użyciu parallelStream() (ryzyko wyścigów i wyjątków). Trudniej go testować i utrzymywać.
Prawidłowo: używaj operacji, które jawnie tworzą nowy wynik bez zmiany zewnętrznego stanu.
List<String> newNames = names.stream()
.filter(name -> name.startsWith("A"))
.collect(Collectors.toList());
4. Błędy z typami i generykami
Java to język silnie typowany. Czasem kompilator nie jest w stanie wywnioskować typów ze zbyt złożonych lambd lub łańcuchów.
Przykład
List<Object> objects = List.of(1, "napis", 3.14);
List<String> strings = objects.stream()
.filter(obj -> obj instanceof String)
.map(obj -> (String) obj)
.collect(Collectors.toList());
Wygląda logicznie, ale każda literówka lub błędne rzutowanie może prowadzić do błędu kompilacji lub, co gorsza, do ClassCastException w czasie wykonania.
Jak uniknąć?
- Dodawaj jawne typy, jeśli wnioskowanie typów się „potyka”.
- Nie bój się pisać <String> ani parametryzować lambd: (String s) -> ....
- Sprawdzaj zgodność typów przy przekształceniach.
Typowy przypadek z Optional
Optional<String> opt = Optional.of("hello");
opt.map(s -> s.length()); // wynik — Optional<Integer>
Jeśli oczekiwaliście Optional<String>, a otrzymaliście Optional<Integer>, sprawdźcie, co zwraca wasza funkcja.
5. Efekty uboczne w lambdach i równoległość
Równoległe strumienie (parallelStream()) plus efekty uboczne to niebezpieczne połączenie.
Przykład
List<Integer> numbers = IntStream.range(0, 1000).boxed().collect(Collectors.toList());
List<Integer> results = new ArrayList<>();
numbers.parallelStream().forEach(n -> results.add(n)); // NIEBEZPIECZNE!
Co może się wydarzyć?
- Utrata lub duplikacja danych.
- ConcurrentModificationException albo „tajemnicze” błędy.
Jak zrobić to poprawnie?
- Używać kolekcji bezpiecznych dla wątków: ConcurrentLinkedQueue, CopyOnWriteArrayList.
- Jeszcze lepiej — w ogóle unikać efektów ubocznych i zbierać wynik przez collect(...).
List<Integer> results = numbers.parallelStream()
.map(n -> n)
.collect(Collectors.toList());
6. Utrata czytelności: „stream-spaghetti” i długie łańcuchy
Styl funkcyjny jest świetny, dopóki łańcuch nie zamienia się w „paragon z hipermarketu”.
List<String> result = list.stream()
.filter(s -> s.length() > 2)
.map(String::trim)
.map(s -> s.toUpperCase())
.filter(s -> s.contains("JAVA"))
.sorted()
.distinct()
.collect(Collectors.toList());
Wskazówki:
- Dziel łańcuchy na logiczne bloki.
- Wyprowadzaj złożone lambdy do osobnych metod z czytelnymi nazwami.
- Dodawaj komentarze w razie potrzeby — nawet w kodzie Stream.
7. Niefortunne nazwy zmiennych i funkcji
Zbyt krótkie nazwy (x, y, z) utrudniają zrozumienie.
list.stream()
.map(x -> x.trim())
.filter(y -> y.length() > 3)
.map(z -> z.toUpperCase())
.forEach(System.out::println);
Używajcie mówiących nazw, zwłaszcza gdy lambda jest wielolinijkowa lub wyraża nietrywialną logikę.
8. Błędy z null i Optional
Stream API i interfejsy funkcyjne nie lubią wartości null. Przekazanie null do lambdy lub strumienia to częsta przyczyna NullPointerException.
List<String> list = Arrays.asList("a", null, "b");
list.stream()
.map(String::toUpperCase) // Bum! NPE na drugim elemencie
.forEach(System.out::println);
Jak zrobić to poprawnie?
- Filtrować null wcześniej: .filter(Objects::nonNull).
- Używać Optional do jawnego przedstawienia braku wartości.
9. Problemy z typem zwracanym w funkcjach złożonych
Przy użyciu compose i andThen łatwo pomylić kolejność zastosowania funkcji i oczekiwane typy.
Function<String, Integer> parse = Integer::parseInt;
Function<Integer, Integer> square = x -> x * x;
Function<String, Integer> parseAndSquare = parse.andThen(square);
// Działa: najpierw parse, potem square
Function<String, Integer> squareThenParse = parse.compose(square);
// Błąd! square przyjmuje Integer, a parse oczekuje String
Morał: zawsze sprawdzaj kolejność zastosowania i zgodność typów.
10. Problemy z wyjątkami sprawdzanymi (checked) w lambdach
Interfejsy funkcyjne z pakietu java.util.function nie dopuszczają wyrzucania wyjątków sprawdzanych (na przykład IOException). Jeśli wewnątrz lambdy potrzebny jest kod, który je rzuca, obsłuż wyjątek ręcznie.
Function<String, String> readFile = path -> {
try {
return Files.readString(Path.of(path));
} catch (IOException e) {
throw new RuntimeException(e); // Albo obsłużyć inaczej
}
};
W przeciwnym razie kompilator nie pozwoli użyć takiej funkcji w strumieniu lub kolekcji.
GO TO FULL VERSION