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ý cezkolekcia.stream(). - Bez vedľajších efektov. V
mapafilternemeňte externé premenné ani kolekcie. Na zber výsledkov jecollect. toList()vracia nemennú kolekciu –addna nej vyhodí výnimku. Ak potrebujete meniteľnú, použiteCollectors.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.