Java - Stream API v praxi: filter, map, groupingBy

Stream API (od Javy 8) umožňuje spracovať kolekcie deklaratívne: namiesto cyklov s pomocnými premennými napíšete čo chcete dostať – vyfiltrovať, prepočítať, zoskupiť – a o ako sa postará knižnica. Kód je kratší a ľahšie sa číta, ak sa nepreženie.

Testovacie dáta

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.*;

record Produkt(String nazov, String kategoria, BigDecimal cena, int sklad) {}

List<Produkt> produkty = List.of(
    new Produkt("Arduino Uno",     "dosky",     new BigDecimal("24.90"), 15),
    new Produkt("ESP32 DevKit",    "dosky",     new BigDecimal("9.50"),  40),
    new Produkt("Raspberry Pi 5",  "dosky",     new BigDecimal("89.00"), 0),
    new Produkt("DHT22",           "senzory",   new BigDecimal("4.20"),  120),
    new Produkt("HC-SR04",         "senzory",   new BigDecimal("1.90"),  200),
    new Produkt("Nepájivé pole",   "príslušenstvo", new BigDecimal("3.50"), 60)
);

Cyklus verzus stream

Úloha: názvy produktov na sklade s cenou do 10 €, zoradené abecedne.

// Klasicky
List<String> vysledok = new ArrayList<>();
for (Produkt p : produkty) {
    if (p.sklad() > 0 && p.cena().compareTo(BigDecimal.TEN) <= 0) {
        vysledok.add(p.nazov());
    }
}
Collections.sort(vysledok);

// So streamom
List<String> vysledok2 = produkty.stream()
    .filter(p -> p.sklad() > 0)
    .filter(p -> p.cena().compareTo(BigDecimal.TEN) <= 0)
    .map(Produkt::nazov)
    .sorted()
    .toList();   // Java 16+, v starších verziách .collect(Collectors.toList())

Stream má tri časti: zdroj (produkty.stream()), medzioperácie (filter, map, sorted), ktoré vracajú nový stream, a jednu koncovú operáciu (toList, count, collect…), ktorá spracovanie spustí. Kým nezavoláte koncovú operáciu, nevykoná sa nič.

Najpoužívanejšie operácie

// map – prevod na iný typ
List<String> velkymi = produkty.stream().map(p -> p.nazov().toUpperCase()).toList();

// count, anyMatch, allMatch, noneMatch
long naSklade = produkty.stream().filter(p -> p.sklad() > 0).count();
boolean nieco = produkty.stream().anyMatch(p -> p.sklad() == 0);   // true

// sorted s komparátorom – podľa ceny zostupne
List<Produkt> odNajdrahsieho = produkty.stream()
    .sorted(Comparator.comparing(Produkt::cena).reversed())
    .toList();

// limit a skip – stránkovanie
List<Produkt> druhaStrana = produkty.stream().skip(2).limit(2).toList();

// Súčty – mapToInt dá IntStream so sum(), average(), max()…
int kusovSpolu = produkty.stream().mapToInt(Produkt::sklad).sum();

// reduce – súčet BigDecimal (pre BigDecimal mapToInt nefunguje)
BigDecimal hodnotaSkladu = produkty.stream()
    .map(p -> p.cena().multiply(BigDecimal.valueOf(p.sklad())))
    .reduce(BigDecimal.ZERO, BigDecimal::add);

Optional – keď výsledok nemusí existovať

Operácie ako findFirst, min alebo max vracajú Optional, pretože stream môže byť prázdny:

Optional<Produkt> najlacnejsi = produkty.stream()
    .filter(p -> p.kategoria().equals("dosky"))
    .min(Comparator.comparing(Produkt::cena));

najlacnejsi.ifPresent(p -> System.out.println("Najlacnejšia doska: " + p.nazov()));

String nazov = produkty.stream()
    .filter(p -> p.nazov().startsWith("STM32"))
    .map(Produkt::nazov)
    .findFirst()
    .orElse("nenájdené");

Vyhýbajte sa optional.get() bez kontroly – pri prázdnom výsledku vyhodí výnimku a celý zmysel Optional sa stratí.

Zoskupovanie – groupingBy

Tu stream ukáže najväčšiu silu. Zoskupenie, na ktoré by bolo treba mapu a niekoľko cyklov, je na pár riadkov:

// Produkty podľa kategórie
Map<String, List<Produkt>> podlaKategorie = produkty.stream()
    .collect(Collectors.groupingBy(Produkt::kategoria));

// Počet produktov v kategórii
Map<String, Long> pocty = produkty.stream()
    .collect(Collectors.groupingBy(Produkt::kategoria, Collectors.counting()));
// {dosky=3, senzory=2, príslušenstvo=1}

// Kusov na sklade podľa kategórie
Map<String, Integer> kusy = produkty.stream()
    .collect(Collectors.groupingBy(Produkt::kategoria, Collectors.summingInt(Produkt::sklad)));

// Iba názvy, zoradené kategórie (TreeMap)
Map<String, List<String>> nazvy = produkty.stream()
    .collect(Collectors.groupingBy(
        Produkt::kategoria,
        TreeMap::new,
        Collectors.mapping(Produkt::nazov, Collectors.toList())));

// Rozdelenie na dve skupiny podľa podmienky
Map<Boolean, List<Produkt>> dostupnost = produkty.stream()
    .collect(Collectors.partitioningBy(p -> p.sklad() > 0));

Prevod na mapu a reťazec

// Mapa názov → cena
Map<String, BigDecimal> cennik = produkty.stream()
    .collect(Collectors.toMap(Produkt::nazov, Produkt::cena));

// Spojenie do reťazca
String zoznam = produkty.stream()
    .map(Produkt::nazov)
    .collect(Collectors.joining(", ", "Ponuka: ", "."));

toMap vyhodí IllegalStateException, ak sa kľúč zopakuje. Ak to môže nastať, pridajte tretí parameter, ktorý určí, čo s duplicitou: Collectors.toMap(Produkt::nazov, Produkt::cena, (prva, druha) -> prva).

flatMap – zoznam zoznamov

record Objednavka(int cislo, List<String> polozky) {}

List<Objednavka> objednavky = List.of(
    new Objednavka(1, List.of("Arduino Uno", "DHT22")),
    new Objednavka(2, List.of("DHT22", "HC-SR04", "DHT22"))
);

// Ktoré produkty sa predávajú najčastejšie
Map<String, Long> predaj = objednavky.stream()
    .flatMap(o -> o.polozky().stream())
    .collect(Collectors.groupingBy(n -> n, Collectors.counting()));
// {DHT22=3, Arduino Uno=1, HC-SR04=1}

map by vrátil stream zoznamov, flatMap ich „sploští“ do jedného streamu položiek.

Na čo si dať pozor

  • Stream sa dá použiť iba raz. Druhá koncová operácia na tom istom streame vyhodí IllegalStateException. Ak ho potrebujete opakovane, vytvorte nový cez kolekcia.stream().
  • Bez vedľajších efektov. V map a filter nemeňte externé premenné ani kolekcie. Na zber výsledkov je collect.
  • toList() vracia nemennú kolekciu – add na nej vyhodí výnimku. Ak potrebujete meniteľnú, použite Collectors.toCollection(ArrayList::new).
  • parallelStream() nie je automaticky rýchlejší. Pri malých kolekciách je réžia vlákien väčšia než úspora. Oplatí sa až pri desaťtisícoch prvkov a výpočtovo náročných operáciách.
  • Čitateľnosť má prednosť. Ak má stream desať krokov a vnorené lambdy, rozdeľte ho na pomenované metódy – alebo použite obyčajný cyklus.
O autorovi

Ing.Jaroslav Vadel

Som zakladateľom www.projectik.eu. Hrám sa na programátora, ktorý ovláda: c#,cpp,java,unity3d,php,html,NI testand,NI Vision Builder,Cognex In-Sight,NI LabView "Naprogramovať program, ktorý funguje vie každy. Ale to, že program funguje ešte neznamena, že je napísany správne "

Súvisiace články