Sobes.tech
Junior

Czym są wyrażenia lambda w Java?

sobes.tech AI

Odpowiedź od AI

Wyrażenie lambda to zwięzła forma funkcji anonimowej, która implementuje metody interfejsu funkcyjnego.

Struktura: (parametry) -> { ciało wyrażenia }.

Część Opis Przykłady
parametry Lista parametrów, może być pusta. Typy mogą nie być wskazane (są wywnioskowane). ()<br>x<br>(x, y)<br>(int x, String y)
-> Operator strzałki (arrow operator). Oddziela parametry od ciała. ->
ciało wyrażenia Ciało lambda. Może być wyrażeniem lub blokiem kodu. x * x<br>{ System.out.println(x); }

Przykłady użycia:

  • Implementacja interfejsów funkcyjnych:

    import java.util.function.Consumer;
    
    // Przed, tradycyjna implementacja za pomocą klasy anonimowej
    Consumer<String> consumerAnon = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumerAnon.accept("Tradycyjna klasa anonimowa");
    
    // Użycie wyrażenia lambda
    Consumer<String> consumerLambda = s -> System.out.println(s);
    consumerLambda.accept("Wyrażenie lambda");
    
  • Praca z API Streams:

    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    
    // Filtrowanie liczb parzystych za pomocą lambda
    List<Integer> evenNumbers = numbers.stream()
                                      .filter(n -> n % 2 == 0)
                                      .collect(Collectors.toList());
    
    System.out.println(evenNumbers); // Wyjście: [2, 4]
    
    // Zamiana liczb na ich kwadraty
    List<Integer> squares = numbers.stream()
                                  .map(n -> n * n)
                                  .collect(Collectors.toList());
    
    System.out.println(squares); // Wyjście: [1, 4, 9, 16, 25]
    

Zalety:

  • Skrócenie kodu w porównaniu do klas anonimowych.
  • Zwiększenie czytelności dla prostych operacji.
  • Łatwość użycia z API Streams i innymi API opartymi na programowaniu funkcyjnym.