Lambdy i strumienie w Javie: filter, map, Comparator

Lambda to funkcja bez nazwy. Po lewej stronie strzałki stoją parametry, po prawej wynik:

• p -> p + 50: jeden parametr
• (a, b) -> a + b: dwa parametry, w nawiasach
• w -> { ... return ...; }: kilka linii w nawiasach klamrowych, z return

Lambda pasuje wszędzie tam, gdzie oczekiwany jest interfejs z dokładnie jedną metodą. Najczęstsze z java.util.function:

• Predicate<T>: warunek, wykonywany przez test(x), zwraca boolean
• Function<T, R>: zamienia T na R, wykonywana przez apply(x)

Listy (zobacz listy i mapy w Javie) mają metody, które przyjmują lambdę: replaceAll zastępuje każdy element, a removeIf usuwa wszystkie, dla których warunek jest spełniony. Jeśli lambda tylko wywołuje istniejącą metodę, krócej zapiszesz to referencją do metody: String::length oznacza s -> s.length(), a Math::max oznacza (a, b) -> Math.max(a, b).

1import java.util.ArrayList;2import java.util.List;3import java.util.function.Function;4import java.util.function.Predicate;5
6public class Main {7    public static void main(String[] args) {8        List<Integer> prices = new ArrayList<>(List.of(250, 399, 120));9        prices.replaceAll(p -> p + 50);10        System.out.println(prices);11
12        Predicate<String> isLong = w -> w.length() > 4;13        System.out.println(isLong.test("Java"));14        System.out.println(isLong.test("Lambda"));15
16        Function<String, String> shout = s -> s.toUpperCase() + "!";17        System.out.println(shout.apply("hello"));18
19        Function<String, Integer> length = String::length;20        System.out.println(length.apply("stream"));21
22        List<String> drinks = new ArrayList<>(List.of("tea", "coffee", "juice", "milk"));23        drinks.removeIf(d -> d.length() < 4);24        System.out.println(drinks);25    }26}

list.stream() zamienia listę w strumień elementów, które przepływają przez niego jeden po drugim. Kolejne kroki łączysz kropkami:

• filter(b -> ...) zostawia tylko elementy, dla których warunek jest spełniony
• map(Book::title) przekształca każdy element
• distinct() usuwa duplikaty, sorted() sortuje

Na końcu stoi krok, który daje wynik:

• toList() zbiera elementy do nowej listy
• mapToInt(...), a potem sum() sumują
• reduce(start, (a, b) -> ...) łączy wszystko w jedną wartość: zaczyna od start i łączy dotychczasowy wynik a z kolejnym elementem b

Pierwotna lista pozostaje przy tym bez zmian.

1import java.util.List;2
3record Book(String title, String genre, int pages) {4}5
6public class Main {7    public static void main(String[] args) {8        List<Book> books = List.of(9                new Book("Dune", "sci-fi", 600),10                new Book("Emma", "classic", 470),11                new Book("Neuromancer", "sci-fi", 270),12                new Book("Persuasion", "classic", 250),13                new Book("Hyperion", "sci-fi", 480));14
15        List<String> longBooks = books.stream()16                .filter(b -> b.pages() > 400)17                .map(Book::title)18                .toList();19        System.out.println(longBooks);20
21        int totalPages = books.stream().mapToInt(Book::pages).sum();22        System.out.println("Pages: " + totalPages);23
24        int maxPages = books.stream().map(Book::pages).reduce(0, Math::max);25        System.out.println("Longest: " + maxPages);26
27        List<String> genres = books.stream()28                .map(Book::genre)29                .distinct()30                .sorted()31                .toList();32        System.out.println(genres);33    }34}

Dzięki Comparable (zobacz dziedziczenie i interfejsy w Javie) klasa ma jedną stałą kolejność sortowania. Comparator to reguła sortowania, którą przekazujesz z zewnątrz:

• Comparator.comparing(Player::points) sortuje rosnąco według punktów
• .reversed() odwraca kolejność
• .thenComparing(Player::name) rozstrzyga remisy

Przekazujesz go do stream().sorted(...) albo do list.sort(...).

collect(Collectors.groupingBy(Player::team, ...)) dzieli elementy na grupy i zwraca mapę: drużyna → wynik. Drugi kolektor określa, co powstaje dla każdej grupy, na przykład Collectors.summingInt(...) dla sumy albo Collectors.counting() dla liczby elementów (jako Long).

1import java.util.Comparator;2import java.util.List;3import java.util.Map;4import java.util.stream.Collectors;5
6record Player(String name, String team, int points) {7}8
9public class Main {10    public static void main(String[] args) {11        List<Player> players = List.of(12                new Player("Mia", "red", 30),13                new Player("Leo", "blue", 45),14                new Player("Ana", "red", 45),15                new Player("Ben", "blue", 20));16
17        List<Player> ranking = players.stream()18                .sorted(Comparator.comparing(Player::points).reversed()19                        .thenComparing(Player::name))20                .toList();21        for (Player p : ranking) {22            System.out.println(p.name() + " " + p.points());23        }24
25        Map<String, Integer> perTeam = players.stream()26                .collect(Collectors.groupingBy(Player::team,27                        Collectors.summingInt(Player::points)));28        System.out.println("red: " + perTeam.get("red"));29        System.out.println("blue: " + perTeam.get("blue"));30
31        Map<String, Long> sizes = players.stream()32                .collect(Collectors.groupingBy(Player::team, Collectors.counting()));33        System.out.println("players in red: " + sizes.get("red"));34    }35}