Programski jezici → Java → Lambda izrazi i Stream API u Javi

Lambda izrazi i Stream API u Javi

Lambda izraz

Lambda ima parametre, strelicu -> i telo: x -> x * x je funkcija koja vraća kvadrat. Tip lambde je funkcijski interfejs – interfejs sa jednom apstraktnom metodom:

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> kvadrat = x -> x * x;          // ulaz -> izlaz
        Predicate<String> dugacka = s -> s.length() > 5;          // ulaz -> true/false
        BiFunction<Integer, Integer, Integer> zbir = (a, b) -> a + b;
        Runnable pozdrav = () -> System.out.println("Zdravo!");   // bez parametara

        System.out.println(kvadrat.apply(7));
        System.out.println(dugacka.test("Java") + " " + dugacka.test("Programiranje"));
        System.out.println(zbir.apply(3, 4));
        pozdrav.run();

        // lambda sa više naredbi: vitičaste zagrade i return
        Function<Integer, String> opis = n -> {
            if (n % 2 == 0) return n + " je paran";
            return n + " je neparan";
        };
        System.out.println(opis.apply(15));
    }
}

Reference na metode

Kada lambda samo poziva postojeću metodu, piše se kraće Klasa::metoda:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> imena = new ArrayList<>(List.of("marko", "Ana", "iva", "Luka"));
        imena.sort(String::compareToIgnoreCase);      // (a, b) -> a.compareToIgnoreCase(b)
        imena.forEach(System.out::println);           // x -> System.out.println(x)
        imena.replaceAll(String::toUpperCase);        // s -> s.toUpperCase()
        System.out.println(imena);
    }
}

Stream: filter, map, sorted, collect

Stream je niz podataka kroz koji elementi „protiču“ kroz korake obrade. Koraci se nadovezuju tačkom, a na kraju stoji završna operacija (collect, count, sum, forEach…):

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> brojevi = List.of(7, 2, 9, 4, 12, 5, 8, 3);

        List<Integer> kvadratiParnih = brojevi.stream()
                .filter(x -> x % 2 == 0)       // zadrži parne: 2, 4, 12, 8
                .map(x -> x * x)               // kvadriraj: 4, 16, 144, 64
                .sorted()                      // sortiraj
                .collect(Collectors.toList());
        System.out.println(kvadratiParnih);

        long vecihOd5 = brojevi.stream().filter(x -> x > 5).count();
        int zbir = brojevi.stream().mapToInt(Integer::intValue).sum();
        double prosek = brojevi.stream().mapToInt(x -> x).average().orElse(0);
        int max = brojevi.stream().max(Integer::compare).get();
        System.out.println(vecihOd5 + " " + zbir + " " + prosek + " " + max);

        String spojeno = brojevi.stream().limit(3).map(String::valueOf).collect(Collectors.joining(" + "));
        System.out.println(spojeno);
    }
}

Stream ne menja originalnu listu – pravi nov rezultat. Jedan stream se može upotrebiti samo jednom.

Stream nad listom objekata

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

public class Main {
    record Proizvod(String naziv, String kategorija, double cena) { }

    public static void main(String[] args) {
        List<Proizvod> p = List.of(
                new Proizvod("Sveska", "skola", 120),
                new Proizvod("Olovka", "skola", 45),
                new Proizvod("Lopta", "sport", 1500),
                new Proizvod("Ranac", "skola", 2900),
                new Proizvod("Reket", "sport", 3200));

        // nazivi proizvoda jeftinijih od 2000, sortirani po ceni
        List<String> jeftini = p.stream()
                .filter(x -> x.cena() < 2000)
                .sorted(Comparator.comparingDouble(Proizvod::cena))
                .map(Proizvod::naziv)
                .toList();
        System.out.println(jeftini);

        // ukupna cena po kategoriji
        Map<String, Double> poKategoriji = p.stream()
                .collect(Collectors.groupingBy(Proizvod::kategorija, TreeMap::new,
                        Collectors.summingDouble(Proizvod::cena)));
        System.out.println(poKategoriji);

        // najskuplji proizvod
        p.stream().max(Comparator.comparingDouble(Proizvod::cena))
                .ifPresent(x -> System.out.println("Najskuplji: " + x.naziv()));
    }
}

max vraća Optional – „kutiju“ koja može biti prazna (ako je lista prazna). ifPresent izvršava kod samo ako vrednost postoji.

Kada stream, a kada petlja?

Stream je pregledan za izdvajanje, preračunavanje i grupisanje podataka. Obična petlja je jasnija kada se koristi indeks, kada se prekida ranije (break) ili kada se menja više promenljivih odjednom. Na takmičenjima se najčešće koriste petlje (brže su za pisanje i izvršavanje), a u aplikacijama (Spring Boot) – streamovi.

Zadaci za vežbu

Za svaki zadatak postoji primer, uputstvo i rešenje. Rešenja su provereno tačna na primerima iz teksta.

Proveri znanje