Java Lambdas and Streams: filter, map, Comparator Explained

A lambda is a function without a name. The parameters go left of the arrow, the result on the right:

• p -> p + 50: one parameter
• (a, b) -> a + b: two parameters, in parentheses
• w -> { ... return ...; }: several lines in braces, with return

A lambda fits wherever an interface with exactly one method is expected. The most common ones from java.util.function:

• Predicate<T>: a condition, run with test(x), returns boolean
• Function<T, R>: turns a T into an R, run with apply(x)

Lists (see lists and maps in Java) have methods that take a lambda: replaceAll replaces every element, removeIf removes all for which the condition holds. If a lambda only calls an existing method, a method reference is shorter: String::length stands for s -> s.length(), Math::max for (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() turns a list into a stream of elements that flow through one after another. You chain the steps with dots:

• filter(b -> ...) keeps only elements for which the condition holds
• map(Book::title) transforms each element
• distinct() removes duplicates, sorted() sorts

At the end comes a step that produces a result:

• toList() collects into a new list
• mapToInt(...) followed by sum() adds up
• reduce(start, (a, b) -> ...) combines everything into one value: it starts at start and combines the result so far, a, with the next element, b

The original list stays unchanged.

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}

With Comparable (see inheritance and interfaces in Java), a class has one fixed order. A comparator is a sorting rule you pass in from outside:

• Comparator.comparing(Player::points) sorts ascending by points
• .reversed() reverses the order
• .thenComparing(Player::name) decides ties

You pass it to stream().sorted(...) or to list.sort(...).

collect(Collectors.groupingBy(Player::team, ...)) splits the elements into groups and returns a map: team → result. The second collector says what comes out per group, such as Collectors.summingInt(...) for a sum or Collectors.counting() for the count (as a 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}