CodeGym /Kursy /JAVA 25 SELF /Analiza błędów w programowaniu funkcyjnym

Analiza błędów w programowaniu funkcyjnym

JAVA 25 SELF
Poziom 49, Lekcja 4
Dostępny

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.

1
Zadanie
JAVA 25 SELF, poziom 49, lekcja 4
Niedostępne
Obliczanie całkowitego przychodu startupu "Kosmiczni Konstruktorzy" 🚀
Obliczanie całkowitego przychodu startupu "Kosmiczni Konstruktorzy" 🚀
1
Zadanie
JAVA 25 SELF, poziom 49, lekcja 4
Niedostępne
Moderacja wiadomości na "Galaktycznym Forum" 💬
Moderacja wiadomości na "Galaktycznym Forum" 💬
1
Ankieta/quiz
Funkcyjne programowanie, poziom 49, lekcja 4
Niedostępny
Funkcyjne programowanie
Funkcyjne programowanie
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION