Generieke typen, lambda-expressies en streams in Java

Een container moet aangeven wat die bevat. Met een typeparameter kan één klasse strings, getallen of je eigen objecten bevatten en controleert de compiler elk gebruik voordat het programma wordt uitgevoerd.

Geef een klasse een typeparameter

In class Box<T> is T een typeparameter: een naam voor een type dat de aanroepende code opgeeft. Gebruik die voor velden, methodeparameters en resultaten.

class Box<T> {
    private T value;

    public Box(T value) { this.value = value; }
    public T get() { return value; }
    public void set(T value) { this.value = value; }
}

De naam van de constructor is Box, zonder <T>. De declaratie na de klassenaam introduceert T voor de klassebody. Maak nu een doos:

Box<String> b = new Box<>("tea");
String drink = b.get();
b.set("water");
System.out.println(drink);   // tea
System.out.println(b.get()); // water

String is het typeargument. Voor deze variabele geeft get() een String terug en accepteert set een String. Bij het lezen is geen expliciete typeconversie nodig. De poging b.set(42) mislukt bij het compileren: “incompatible types: int cannot be converted to String”. De fout wijst de verkeerde schrijfbewerking aan voordat een latere leesbewerking kan mislukken.

Waarom geen Object opslaan?

Een Object-veld kan verwijzen naar een string of een geheel getal. Code die een string nodig heeft, moet het teruggegeven object expliciet naar dat type omzetten. Als een geheel getal is opgeslagen, werpt die conversie tijdens de uitvoering een ClassCastException op. Een Box<String> maakt het bedoelde verband onderdeel van het gedeclareerde type.

De diamant <> in new Box<>("tea") vraagt de compiler de typeargumenten af te leiden. De controles blijven behouden. Als je de punthaken helemaal weglaat, zoals in new Box("tea"), gebruik je een ruw type en verlies je controles met de typeparameter. Als je een constructie met een ruw type aan een getypeerde variabele toewijst, ontstaan waarschuwingen voor niet-gecontroleerde typeveiligheid; de getypeerde variabele blijft bij latere aanroepen haar eigen gedeclareerde typeargument afdwingen.

Gebruik wrappers en meerdere parameters

Een typeargument moet een referentietype zijn. Gebruik Box<Integer>, niet Box<int>. Java zet de literal 5 via autoboxing om in een Integer bij het construeren van new Box<Integer>(5) en zet die via unboxing terug wanneer een berekening een int nodig heeft. Als n die doos bevat, geeft int next = n.get() + 1; de waarde 6.

Twee onafhankelijke typen vereisen twee parameters. Een Pair<K, V> kan een veld K first en een veld V second hebben. Voor een Pair<String, Integer> geven de getters een String en een Integer terug. Gebruikelijke namen zijn T voor een type, E voor een element, K en V voor een sleutel en waarde, en R voor een resultaat.

Zet typeparameters op interfaces

interface Container<T> {
    void put(T item);
    T take();
}

Een klasse kan de keuze openlaten met class Shelf<T> implements Container<T>, of vastleggen met class NameList implements Container<String>. List<E> en Comparable<T> gebruiken hetzelfde idee. Een generieke klasse blijft één klasse: Box<String> en Box<Integer> beschrijven verschillende toepassingen die tijdens het compileren worden gecontroleerd, geen twee klassendeclaraties. Je kunt ze niet aan elkaar toewijzen omdat ze verschillende elementtypen beloven.

Sommige bewerkingen hebben een typekeuze nodig voor één aanroep, niet voor de levensduur van een object. Een generieke methode introduceert haar eigen typeparameter en behoudt een verband tussen haar invoer en resultaat.

Declareer het type vóór het retourtype

import java.util.List;

class Lists {
    public static <T> T last(List<T> list) {
        return list.get(list.size() - 1);
    }

    public static void main(String[] args) {
        int number = last(List.of(4, 8, 15));
        String word = Lists.<String>last(List.of("x", "y"));
        System.out.println(number); // 15
        System.out.println(word);   // y
    }
}

Lees de declaratie in delen. static maakt er een klassenmethode van. <T> introduceert een typeparameter die bij de methode hoort. De volgende T is het retourtype. List<T> geeft aan dat de invoerlijst en het resultaat hetzelfde elementtype hebben.

Voor de eerste aanroep leidt Java Integer af voor T. Het resultaat kan dan via unboxing worden omgezet naar int. In de tweede aanroep is <String> een expliciet methodetypeargument, geplaatst tussen de punt en de methodenaam. Lists.last(...) zou hier hetzelfde type afleiden. Een expliciet methodetypeargument heeft iets vóór de punt nodig: een klassenaam voor een statische methode of een object zoals this voor een instantiemethode.

Deze methode verwacht een niet-lege lijst. Bij een lege lijst is size() - 1 gelijk aan -1, dus werpt get een IndexOutOfBoundsException op. Generieke typen controleren typen; ze bewijzen niet dat een index bestaat.

Verbind meerdere typen

Een generieke methode kan meerdere parameters introduceren. Gegeven een klasse Pair<K, V> met een constructor en getters, draait deze volledige methode de rollen om:

static <K, V> Pair<V, K> swap(Pair<K, V> p) {
    return new Pair<>(p.getSecond(), p.getFirst());
}

Voor een invoerpaar ("Ada", 36) van het type Pair<String, Integer> is het resultaat (36, "Ada") van het type Pair<Integer, String>. De retourdeclaratie legt het verband vast; een retourtype Object zou het verbergen en de aanroepende code dwingen tot een expliciete typeconversie.

Een methode zoals <T> int countEqual(List<T> list, T target) brengt ook invoerwaarden met elkaar in verband. De lus kan elk element met target vergelijken via equals. Bij ["a", "b", "a", "c", "a"] en "a" is de telling 3. Typeafleiding kan voor argumenten een gemeenschappelijk supertype kiezen, dus het herhalen van T dwingt niet altijd af dat twee argumentexpressies identieke gedeclareerde typen hebben.

Bepaal waar de typeparameter bij hoort

Een Box<String> behoudt zijn typeargument bij gebruik van dat object. Lists.last kiest voor elke aanroep opnieuw een typeargument. Een gewone hulpklasse kan daarom generieke statische methoden bevatten zonder zelf generiek te zijn.

Een statische methode binnen Box<T> kan de T van de klasse niet gebruiken: de statische methode behoort tot de gedeelde klasse, niet tot één doos. Declareer een afzonderlijke parameter, bijvoorbeeld static <E> Box<E> of(E value). Als een methodedeclaratie begint met static T first(...) zonder een eigen <T> voor de methode, meldt de compiler in een gewone klasse dat hij T niet kan vinden. Voeg de declaratie vóór het retourtype toe; als je het retourtype verandert in Object, gaat het nuttige verband verloren.

Een onbeperkte T ondersteunt alleen bewerkingen die op Object beschikbaar zijn. Typegrenzen voegen een nuttige garantie toe. Met jokers kan een parameter een reeks generieke typen accepteren zonder te doen alsof al hun elementtypen identiek zijn.

Vereis de bewerkingen die je nodig hebt

static <T extends Comparable<T>> T largest(List<T> list) {
    T best = list.get(0);
    for (T x : list) {
        if (x.compareTo(best) > 0) {
            best = x;
        }
    }
    return best;
}

De typegrens geeft aan dat een T zichzelf kan vergelijken met een andere T. De aanroep largest(List.of(3, 11, 7)) begint met 3, vervangt de beste waarde door 11 en laat die bij 7 ongewijzigd. De methode geeft 11 terug. Voor ["pear", "apple", "plum"] is "plum" het grootste woord in natuurlijke volgorde. Bij een lege lijst mislukt get(0).

extends introduceert ook typegrenzen voor interfaces. <T extends Number> maakt doubleValue() beschikbaar. Meerdere typegrenzen gebruiken &, met een eventuele klasse voorop: <T extends Number & Comparable<T>>.

Waarom List geen List is

Integer is een subklasse van Number, maar List<Integer> is geen subtype van List<Number>. Generieke typen zijn invariant. Als die toewijzing was toegestaan, zou code die de List<Number>-referentie gebruikt een Double kunnen toevoegen; de oorspronkelijke eigenaar zou die vervolgens als een Integer lezen. Een parameter List<Number> accepteert wel implementaties zoals ArrayList<Number>, maar wijst List<Integer> af.

Lees met extends; voeg toe met super

static double sum(List<? extends Number> nums) {
    double total = 0;
    for (Number n : nums) total += n.doubleValue();
    return total;
}

static void addOneToThree(List<? super Integer> target) {
    target.add(1);
    target.add(2);
    target.add(3);
}

? extends Number betekent één onbekend type dat Number of een subtype daarvan is. sum accepteert lijsten met gehele getallen, kommagetallen of getallen. De methode leest elk element als een Number. sum(List.of(1.5, 2.5)) geeft 4,0. De methode kan geen 3 toevoegen: het onbekende elementtype kan Double zijn. De typeregels staan het toevoegen van null toe, al kan een specifieke lijst dit tijdens de uitvoering afwijzen.

? super Integer betekent Integer of een supertype daarvan. De tweede methode kan gehele getallen toevoegen aan een wijzigbare List<Integer>, List<Number> of List<Object>. Een waarde die via die parameter wordt gelezen, heeft alleen het type Object: bestaande elementen kunnen andere getallen of objecten zijn.

Het ezelsbruggetje is producent: extends, consument: super. Het beschrijft de richting waarin elementen worden doorgegeven, niet of de hele collectie onveranderlijk is. Zo kan het nog steeds mogelijk zijn om via een extends-weergave elementen te verwijderen.

Gebruik een benoemde typeparameter als een type meerdere posities moet verbinden, vooral een invoer- en een retourtype. Gebruik een joker als alleen een reeks geaccepteerde invoertypen van belang is. Collections.copy leest uit List<? extends T> en schrijft naar List<? super T>; de doellijst moet al genoeg posities hebben om te vervangen.

Generieke typen geven de compiler meer informatie dan een gewone klassentest tijdens de uitvoering heeft. Als je begrijpt wat na het compileren overblijft, begrijp je ook waarschuwingen over ruwe typen en verschillende bewerkingen die Java afwijst.

Wat typewissing verwijdert

Java controleert typeargumenten en wist daarna typeparameters tot hun typegrenzen. Een onbegrensde T wordt Object; een T extends Number wordt Number. De compiler voegt waar nodig expliciete typeconversies in wanneer waarden worden gelezen. Tijdens de uitvoering is er één klasse Box, dus dit geeft true weer:

System.out.println(
    new Box<String>("a").getClass()
    == new Box<Integer>(1).getClass()
);

De declaratie van Box kan de generieke klasse zijn met een waardeveld, constructor en getter. Beide constructies hebben tijdens de uitvoering dezelfde klasse, ook al gelden voor hun gedeclareerde toepassingen verschillende controles tijdens het compileren.

Bewerkingen die tijdens de uitvoering een bekend type nodig hebben

Binnen een generieke klasse compileert new T() niet. Java weet niet welke constructor het type van de aanroepende code heeft. Accepteer een fabriek om de waarde te maken:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

class Factory {
    static <T> T create(Supplier<T> factory) {
        return factory.get();
    }

    public static void main(String[] args) {
        List<String> words = create(ArrayList::new);
        words.add("ready");
        System.out.println(words); // [ready]
    }
}

De supplier levert het gedrag om de waarde te maken. Ook new T[10] en new List<Integer>[2] worden afgewezen omdat ze een generieke array proberen te maken. Sla een reeks op in ArrayList<T> als je geen arraygedrag nodig hebt.

Voor een Object obj kan obj instanceof List<String> het elementtypeargument niet veilig testen. Gebruik obj instanceof List<?> om te testen of het een lijst is en behandel de elementen daarna als onbekend. Die test stelt niet vast dat het elementtype string is.

Gedeelde statische leden en overladen methoden na typewissing

Een veld zoals static T shared kan de T van de omsluitende klasse niet gebruiken. Alle parametrisaties delen het statische lid. Een statische methode kan een eigen <E> introduceren, onafhankelijk van de klasseparameter.

Twee overladen methoden print(Set<String> s) en print(Set<Integer> s) kunnen niet naast elkaar bestaan in één klasse. Beide worden na typewissing een methode die Set accepteert, waardoor een naamconflict ontstaat. Geef de bewerkingen verschillende namen of ontwerp één methode die het gemeenschappelijke gedrag afhandelt.

Volg een waarschuwing voor niet-gecontroleerde typeveiligheid tot de verkeerde leesbewerking

List raw = new ArrayList();
raw.add("text");
raw.add(42);
for (Object value : raw) {
    String text = (String) value;
    System.out.println(text);
}

Dit geeft text weer, waarna de expliciete typeconversie van 42 een ClassCastException opwerpt. De declaratie met een ruw type kan een melding over het ruwe type opleveren; de toevoegingen leveren waarschuwingen over niet-gecontroleerde aanroepen op omdat generieke controles zijn omzeild. Als je de declaratie vervangt door List<String>, verschuift de fout naar add(42) tijdens het compileren. Een waarschuwing voor niet-gecontroleerde typeveiligheid wijst op een verloren garantie en een risico op mislukking tijdens de uitvoering. Herstel het gebruik van het ruwe type of de onveilige conversie in plaats van aan te nemen dat een latere leesbewerking veilig is.

Een methode kan een regel als argument accepteren. Met een lambda-expressie schrijf je die regel waar je hem gebruikt, terwijl een functionele interface Java vertelt welke invoer de regel krijgt en wat die teruggeeft.

Voldoe aan één abstracte methode

Een functionele interface heeft één te implementeren abstracte methode. Declaraties die overeenkomen met publieke instantiemethoden van Object, zoals equals(Object), tellen niet mee. Default-methoden en statische methoden voegen geen abstracte methoden toe die moeten worden geïmplementeerd. Comparator<T> en Runnable zijn functionele interfaces.

@FunctionalInterface
interface Operation {
    int apply(int a, int b);
}

class Combine {
    static int combine(int a, int b, Operation op) {
        return op.apply(a, b);
    }

    public static void main(String[] args) {
        Operation add = (a, b) -> a + b;
        System.out.println(add.apply(3, 4)); // 7
        System.out.println(combine(3, 4, (x, y) -> x * y)); // 12
    }
}

De interface levert de methodenaam apply, de twee parametertypen int en het resultaattype int. De lambda-expressie levert de parameternamen en de body. Ze maakt een implementatie die via Operation kan worden gebruikt; die implementatie wordt pas uitgevoerd wanneer het programma apply aanroept.

combine geeft zijn twee getallen altijd door aan op. De aanroepende code verandert het gedrag door optellen of vermenigvuldigen op te geven. Zo ontvangt ook sort een ordeningsregel en filter een voorwaarde.

Lees de syntaxis

Een lambda-expressie heeft parameters, -> en daarna een expressie of een blok. Bij één afgeleide parameter mogen de haakjes weg: w -> w.length() > 5. Bij nul parameters is () nodig en bij twee of meer zijn haakjes nodig, zoals in (a, b) -> a * b. Expliciete typen zijn toegestaan: (int a, int b) -> a + b.

Een expressiebody geeft het resultaat automatisch terug. Een blok dat een waarde oplevert, moet die teruggeven:

Operation max = (a, b) -> {
    if (a > b) {
        return a;
    }
    return b;
};
System.out.println(max.apply(3, 9)); // 9

Elk pad door dit blok geeft een int terug. Als je accolades rond a + b zet zonder return, ontstaat geen geldig blok dat een waarde teruggeeft.

Laat het doeltype de betekenis bepalen

Het doeltype is de functionele interface die wordt verwacht bij een toewijzing, argument of retourpositie. De tekst x -> x * 2 kan passen bij Function<Integer, Integer> of UnaryOperator<Integer>. De parameter- en resultaattypen komen uit dat doeltype. Object o = () -> 1; mislukt omdat Object geen functionele methode biedt.

@FunctionalInterface vraagt de compiler de interfacedefinitie te controleren. Het is een nuttige bescherming als iemand later een tweede afzonderlijke abstracte methode toevoegt. Zonder de annotatie kan zo'n interface nog steeds worden gedeclareerd, maar een lambda-expressie kan de twee afzonderlijke vereisten niet implementeren.

Een lambda-expressie kan ook conflicteren met lokale namen. Als de omringende methode al int a declareert, kan ze binnen dat bereik geen lambdaparameter met de naam a declareren. Kies een andere parameternaam. Vergeleken met een anonieme klasse die Comparator<String> implementeert, laat een lambda-expressie de herhaalde klasse- en methodedeclaratie weg; de berekening voor de ordening moet nog steeds aan het comparatorcontract voldoen.

Java heeft al namen voor veelvoorkomende vormen van gedrag. Kies een interface op basis van het aantal invoerwaarden en het soort resultaat en roep daarna de functionele methode aan om het gedrag uit te voeren.

Kies de vorm van invoer en uitvoer

Deze interfaces staan in java.util.function. Voor strings past w -> w.length() > 5 bij een predicaat, String::length bij een functie die Integer teruggeeft en System.out::println bij een consument. Een leverancier zoals () -> new ArrayList<String>() maakt telkens wanneer get() wordt uitgevoerd een nieuwe lijst. Een voorwaarde die door filter wordt gebruikt, vereist Predicate<T>, ook al zou een Function<T, Boolean> in andere code ook een booleaanse waarde kunnen berekenen.

UnaryOperator<T> is een functie van T naar dezelfde T. BinaryOperator<T> combineert twee waarden van het type T tot een T. BiFunction<T, U, R>, BiPredicate<T, U> en BiConsumer<T, U> nemen twee invoerwaarden. Primitieve vormen vermijden boxing: IntPredicate.test(int), IntBinaryOperator.applyAsInt(int, int) en ToIntFunction<T>.applyAsInt(T).

Combineer regels in een bepaalde volgorde

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

class Rules {
    public static void main(String[] args) {
        Predicate<String> isLong = w -> w.length() > 5;
        Predicate<String> longB = isLong.and(w -> w.startsWith("b"));
        System.out.println(longB.test("banana")); // true
        System.out.println(isLong.negate().test("kiwi")); // true

        Function<Integer, Integer> twice = x -> x * 2;
        Function<Integer, Integer> inc = x -> x + 1;
        System.out.println(twice.andThen(inc).apply(5)); // 11
        System.out.println(twice.compose(inc).apply(5)); // 12
    }
}

and vereist dat beide voorwaarden gelden, or dat minstens één geldt en negate keert het antwoord om. Predicate.not(p) ontkent ook een predicaat. andThen voert eerst de ontvanger uit; compose voert eerst zijn argument uit. Hier berekent de eerste keten eerst 10 en dan 11, terwijl de tweede eerst 6 en dan 12 berekent.

Geef een regel door aan een methode

static <T> List<T> keep(List<T> list, Predicate<T> test) {
    List<T> kept = new ArrayList<>();
    for (T x : list) {
        if (test.test(x)) kept.add(x);
    }
    return kept;
}

keep(List.of(4, 9, 12, 15), n -> n % 3 == 0) geeft [9, 12, 15]. Met T werkt de methode voor verschillende elementtypen; het predicaat maakt het selectiegedrag herbruikbaar.

Voor een wijzigbare lijst [3, 8, 1, 10, 6] laat removeIf(n -> n < 5) [8, 10, 6] over. replaceAll(n -> n * 2) geeft daarna [16, 20, 12]. Deze methoden wijzigen de lijst; forEach accepteert een consument voor acties zoals weergeven. Kopieer een resultaat van List.of(...) naar een ArrayList voordat je bewerkingen gebruikt die de lijst wijzigen.

Voor maps accepteert forEach((key, value) -> ...) een BiConsumer. merge(word, 1, Integer::sum) slaat 1 op voor een nieuw woord en verhoogt een bestaande telling. computeIfAbsent(key, k -> new ArrayList<>()) maakt een waarde voor een ontbrekende sleutel of een sleutel die aan null is gekoppeld en geeft de resulterende waarde terug. Deze methoden houden de zoek- en bijwerkregel bij elkaar.

Een lambda-expressie kan informatie uit de omringende methode gebruiken. Als de body alleen één bestaande methode aanroept, drukt een methodereferentie hetzelfde gedrag vaak directer uit.

Leg een lokale variabele vast

int limit = 10;
Predicate<Integer> small = n -> n < limit;
System.out.println(small.test(7)); // true

De lambda-expressie gebruikt het vastleggen van limit. Een vastgelegde lokale variabele moet final of effectief final zijn: eenmaal toegewezen en nooit opnieuw toegewezen. Als je ergens na die eerste toewijzing limit = 20; toevoegt, compileert het vastleggen niet meer, ook als de hertoewijzing vóór de lambda-expressie staat.

De regel geldt voor de lokale variabele, niet voor de hele toestand binnen het object. Dit compileert:

StringBuilder log = new StringBuilder();
Runnable action = () -> log.append("ran");
action.run();
System.out.println(log); // ran

log verwijst nog steeds naar dezelfde builder. Een veld van het omringende object bijwerken is ook toegestaan, maar verborgen wijzigingen kunnen gedrag moeilijk te volgen maken.

Als je numbers.forEach(n -> total += n) probeert met een lokale int total = 0, mislukt dat omdat de vastgelegde variabele verandert. Gebruik een lus als de taak een bijwerking is, of bereken een resultaat rechtstreeks met numbers.stream().mapToInt(n -> n).sum().

Lees de vier referentievormen

Een methodereferentie gebruikt ::, zonder argumentenlijst. De functionele interface als doeltype levert de invoer en het verwachte resultaat.

Bij de gebonden referentie ligt de ontvanger al vast: de PrintStream waarnaar System.out verwijst. Bij de ongebonden referentie wordt het eerste functionele argument de ontvanger. Zo komt String::compareToIgnoreCase overeen met (a, b) -> a.compareToIgnoreCase(b): de eerste string is de ontvanger en de tweede is het methodeargument.

Stem de referentie af op een doeltype

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;

class References {
    public static void main(String[] args) {
        Function<String, Integer> parse = Integer::parseInt;
        Function<String, Integer> length = String::length;
        Supplier<List<String>> fresh = ArrayList::new;
        System.out.println(parse.apply("42")); // 42
        System.out.println(length.apply("stream")); // 6
        System.out.println(fresh.get()); // []
    }
}

Een constructorreferentie kan ook argumenten aannemen. Student::new past bij een Function<String, Student> als een passende constructor één String als argument neemt. Het doeltype bepaalt welke overladen constructor wordt geselecteerd.

Student::getName verwijst naar een instantiegetter op elke meegegeven student; er is geen statische getter voor nodig. Schrijf een lambda-expressie als er extra werk is, zoals in s -> s.getPoints() * 2 of w -> w.length() > 5. String::length() schrijven is ongeldig: de referentie benoemt gedrag zonder het daar aan te roepen.

De natuurlijke volgorde van een object is niet altijd de volgorde die een taak nodig heeft. Met een afzonderlijke Comparator<T> kun je dezelfde objecten volgens verschillende regels sorteren zonder hun klasse te wijzigen.

Lees het teken van compare

compare(a, b) geeft een negatief getal terug als a eerst komt, nul als beide dezelfde sorteerrang hebben en een positief getal als a na b komt. Alleen het teken telt. Een comparator geeft geen booleaanse waarde terug.

Comparable<T> hoort bij de klasse en levert haar natuurlijke volgorde via compareTo. Een comparator is een afzonderlijke waarde die aan een sorteermethode wordt doorgegeven. Strings hebben een natuurlijke tekenvolgorde, maar een comparator kan ze in plaats daarvan op lengte sorteren.

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

class SortWords {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("ccc", "a", "bb"));
        Comparator<String> byLength =
            (a, b) -> Integer.compare(a.length(), b.length());
        words.sort(byLength);
        System.out.println(words); // [a, bb, ccc]
    }
}

De comparator haalt de lengtes op en vergelijkt de getallen. words.sort wijzigt de wijzigbare lijst en heeft retourtype void; de methode geeft geen nieuwe lijst terug. Het sorteren van een resultaat van List.of(...) werpt een UnsupportedOperationException op, dus maakt het voorbeeld eerst een kopie als ArrayList.

Vergelijk getallen veilig

Gebruik Integer.compare of Double.compare. Aftrekken kan door overloop het teken omkeren: 2_000_000_000 - (-2_000_000_000) levert als int −294.967.296 op. Daardoor komt het grotere getal ten onrechte eerst in oplopende volgorde. Integer.compare(2_000_000_000, -2_000_000_000) geeft correct 1 terug.

Als je een verschil van doubles expliciet omzet naar int, gaat ook informatie verloren. (int) (1.2 - 0.7) is 0, hoewel de eerste waarde groter is. Double.compare(1.2, 0.7) geeft een positief resultaat.

Houd de ordening consistent

Als je de invoerwaarden omdraait, moet het teken van de vergelijking omkeren. Als a vóór b komt en b vóór c, moet a vóór c komen. Waarden die bij vergelijking nul opleveren, moeten ten opzichte van elke andere waarde dezelfde sorteerrang hebben. Schending van deze regels kan een verkeerde volgorde opleveren of ervoor zorgen dat de sortering een IllegalArgumentException opwerpt met “Comparison method violates its general contract!”. Als je alleen 0 of 1 teruggeeft, kun je niet beide richtingen uitdrukken.

Java's lijstsorteringen en sorteringen van objectarrays met een comparator zijn stabiel: bij een gelijke sorteerrang blijft de oorspronkelijke volgorde behouden. Voor de studenten Ada 85, Ben 72, Chen 85, Dara 90 en Eli 64 geeft sorteren op oplopende punten de volgorde Eli, Ben, Ada, Chen, Dara. Ada blijft vóór Chen omdat hun scores gelijk zijn en Ada eerst stond.

De studentenvoorbeelden gebruiken deze klasse en een wijzigbare lijst:

class Student {
    private final String name;
    private final String group;
    private final int points;

    Student(String name, String group, int points) {
        this.name = name;
        this.group = group;
        this.points = points;
    }
    String getName() { return name; }
    String getGroup() { return group; }
    int getPoints() { return points; }
}

List<Student> students = new ArrayList<>(List.of(
    new Student("Ada", "A", 85), new Student("Ben", "B", 72),
    new Student("Chen", "A", 85), new Student("Dara", "B", 90),
    new Student("Eli", "A", 64)));
students.sort(Comparator.comparingInt(Student::getPoints));
students.forEach(s -> System.out.println(s.getName()));
// Eli, Ben, Ada, Chen, Dara, each on a separate line

Kies een manier om te sorteren

list.sort(cmp) en Collections.sort(list, cmp) wijzigen een wijzigbare lijst. list.sort(null) vraagt om de natuurlijke volgorde. Arrays.sort(array, cmp) accepteert een objectarray zoals Integer[]; voor een int[] is er geen overladen variant met een comparator.

De natuurlijke volgorde van strings vergelijkt UTF-16-code-eenheden. Hoofdletters A–Z komen vóór kleine letters a–z, dus ["banana", "Cherry", "apple"] wordt [Cherry, apple, banana]. String.CASE_INSENSITIVE_ORDER geeft voor die woorden [apple, banana, Cherry]. Kies de tekstregel expliciet wanneer hoofdlettergebruik de volgorde niet mag bepalen.

Een ordening met meerdere sleutels lees je het gemakkelijkst als een reeks beslissingen: vergelijk de hoofdsleutel en vergelijk daarna alleen een tweede sleutel als de eerste gelijk is. Opbouwmethoden voor comparators drukken die beslissingen rechtstreeks uit.

Haal een sleutel op en sorteer gelijke waarden verder

Voor een Student met getName(), getGroup() en getPoints() ordent Comparator.comparing(Student::getName) op naam. comparingInt(Student::getPoints) haalt een int op zonder boxing.

Comparator<Student> ranking =
    Comparator.comparingInt(Student::getPoints)
        .reversed()
        .thenComparing(Student::getName);

Dit zet hoge punten eerst en sorteert bij gelijke punten de namen in oplopende volgorde. Voor Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64) geeft dit Dara, Ada, Chen, Ben, Eli. De naamvergelijking wordt alleen uitgevoerd bij gelijke punten.

Plaats reversed op het juiste niveau

reversed() keert alles om wat ervoor is opgebouwd. Als je de rangschikking na thenComparing omkeert, keren ook de namen binnen elke gelijke score om. Om groepen oplopend en punten binnen elke groep aflopend te ordenen, keer je alleen de puntencomparator om:

Comparator<Student> byGroup =
    Comparator.comparing(Student::getGroup)
        .thenComparing(
            Comparator.comparingInt(Student::getPoints).reversed());

Het resultaat is Ada, Chen, Eli, Dara, Ben: groep A komt vóór B; binnen A komt 85 vóór 64. Als je .reversed() in plaats daarvan aan het einde zet, keren zowel de groepsvolgorde als de puntenvolgorde ten opzichte van de voorgaande keten om.

Kies regels voor tekst en null

Comparator.naturalOrder() volgt Comparable; reverseOrder() keert die volgorde om. Geef een sleutelcomparator op als een sleutel speciale behandeling nodig heeft, zoals in Comparator.comparing(Student::getName, String.CASE_INSENSITIVE_ORDER).

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

class SortNullable {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("b");
        words.add(null);
        words.add("a");
        words.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
        System.out.println(words); // [null, a, b]
    }
}

Omhul de vergelijking op het niveau waar null voorkomt. nullsLast rond de hele studentencomparator handelt null-studentobjecten af. Een functie die een naam ophaalt en null teruggeeft, heeft een comparator met expliciete null-afhandeling voor de naamsleutel zelf nodig. Comparators voor natuurlijke volgorde en gewone sleutelcomparators handelen null-sleutels niet automatisch af.

Sorteer sleutel-waardeparen en los typeafleiding op

Een HashMap garandeert geen bronvolgorde. Maak een stream van de sleutel-waardeparen en kies expliciet een volgorde:

stock.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
    .forEach(System.out::println);

Voor rice=12, oats=3 en flour=7 geeft dit rice=12, flour=7, oats=3 weer, elk op een afzonderlijke regel. De sleutel-waardeparen in de stream worden geordend zonder stock opnieuw te ordenen. Voeg thenComparing(Map.Entry.comparingByKey()) toe als gelijke waarden een voorspelbare sleutelvolgorde nodig hebben.

Het expliciete <String, Integer> helpt bij de typeafleiding over de geketende aanroep heen. Zo kan Comparator.comparing(s -> s.getName()).reversed() ook s afleiden als Object. Gebruik Student::getName of (Student s) -> s.getName() om het ontbrekende type op te geven. Een benoemde comparator kun je opnieuw gebruiken bij het sorteren van lijsten, bij sorted, min en max op streams, of bij een geordende map of verzameling.

Een stream beschrijft hoe je een reeks waarden verwerkt. Een stream leest uit een bron, geeft elementen door tussenbewerkingen en eindigt met een eindbewerking die een resultaat oplevert of een actie uitvoert.

Herken de drie onderdelen

import java.util.List;

class CountPasses {
    public static void main(String[] args) {
        List<Integer> points = List.of(72, 45, 90, 58, 81);
        long passed = points.stream()
            .filter(p -> p >= 60)
            .count();
        System.out.println(passed); // 3
        System.out.println(points); // [72, 45, 90, 58, 81]
    }
}

points.stream() is de bron. filter is een tussenbewerking: die geeft een andere stream terug. count is de eindbewerking: die geeft een long terug. De waarden 72, 90 en 81 komen door het filter. Door via de stream te lezen zijn 45 en 58 niet uit points verwijderd.

Kies een bron

Collecties bieden stream(). Een map biedt streams via entrySet(), keySet() of values(). Arrays.stream(array) maakt een stream van arrayelementen; een int[] levert een IntStream op. Stream.of("a", "b", "c") levert opgesomde waarden.

IntStream.range(1, 5) bevat 1, 2, 3, 4, zonder de eindwaarde. rangeClosed(1, 5) bevat ook 5 en heeft als som 15. Stream.iterate(1, n -> n * 2) heeft geen vast eindpunt; .limit(5).toList() verzamelt [1, 2, 4, 8, 16]. Een begrensd resultaat is essentieel bij het verwerken van die oneindige reeks.

Volg luie evaluatie

Tussenbewerkingen worden lui geëvalueerd. Alleen names.stream().map(String::toUpperCase); schrijven voert de transformaties niet uit. Een eindbewerking start de verwerking en elementen worden alleen verwerkt als dat nodig is.

String first = java.util.stream.Stream.of("one", "two", "three", "four")
    .filter(w -> w.length() > 3)
    .map(String::toUpperCase)
    .findFirst()
    .orElse("none");
System.out.println(first); // THREE

De eerste twee woorden komen niet door het filter. "three" komt erdoor, wordt "THREE" en voldoet aan findFirst. Het laatste woord is niet nodig. Dit is voortijdig stoppen zodra het resultaat vaststaat: het antwoord is bekend voordat de hele bron is gelezen.

sorted heeft alle invoer nodig voordat het de eerste gesorteerde waarde kan doorgeven. Sommige andere toestandsafhankelijke bewerkingen, zoals sequentieel distinct, kunnen waarden doorgeven zodra invoer binnenkomt. De plaats van een bewerking in de keten beïnvloedt hoeveel werk nodig is.

Maak een nieuwe stream voor een ander resultaat

Na een eindbewerking is de stream verbruikt. Als je die stream opnieuw gebruikt, wordt meestal een IllegalStateException opgeworpen met “stream has already been operated upon or closed”. Roep voor een andere verwerkingspijplijn opnieuw points.stream() aan. Een collectie is herbruikbare opslag; een stream is één verwerkingspad.

Een stream maken kopieert de elementen niet. Houd de bron ongewijzigd terwijl je die verwerkt. map produceert omgezette waarden; de bewerking schrijft die niet terug naar de lijst. Voor bewuste wijzigingen aan een lijst drukken methoden zoals replaceAll en removeIf die taak rechtstreeks uit. Gebruik één bewerking per regel, zodat de verwerkingsvolgorde en het resultaattype zichtbaar blijven.

Volg na elke bewerking zowel de waarden als hun type: een latere lambda-expressie ontvangt het huidige streamelement, niet het oorspronkelijke bronobject.

Selecteer vóór het transformeren

filter behoudt elementen die aan een predicaat voldoen. map vervangt elk element door een berekende waarde. Bij studenten met getters voor naam en punten moet het selecteren op punten gebeuren vóór de omzetting naar namen:

List<String> names = students.stream()
    .filter(s -> s.getPoints() >= 80)
    .map(Student::getName)
    .sorted()
    .toList();

Voor Ada 85, Ben 72, Chen 85, Dara 90 en Eli 64 levert dit [Ada, Chen, Dara] op. Vóór map is het elementtype Student. Daarna is het type String, zodat een getter voor punten niet langer beschikbaar is.

Ga over naar een primitieve stream

Stream<Integer> bevat referenties naar wrapperobjecten en heeft geen methode sum(). mapToInt(Integer::intValue) levert een IntStream op, die numerieke bewerkingen biedt. mapToInt(String::length) meet op dezelfde manier strings als primitieve lengtes.

import java.util.List;
import java.util.stream.IntStream;

class Windows {
    public static void main(String[] args) {
        List<Integer> window = IntStream.rangeClosed(1, 10)
            .skip(2)
            .limit(3)
            .boxed()
            .toList();
        System.out.println(window); // [3, 4, 5]
    }
}

skip(2) verwijdert 1 en 2 uit de stream. limit(3) behoudt de volgende drie waarden. Als je die aanroepen omdraait, blijft alleen 3 over. boxed() keert terug naar Stream<Integer>, zodat de elementen als objecten kunnen worden verzameld. mapToObj maakt andere objecten van primitieve waarden; streams met long- en double-waarden hebben overeenkomstige conversiebewerkingen.

Verwijder duplicaten en kies een volgorde

distinct gebruikt objectgelijkheid. ["map", "filter", "map", "sorted", "filter"] wordt [map, filter, sorted], waarna sorted() [filter, map, sorted] geeft. Implementeer voor je eigen klassen consistente methoden equals en hashCode als overeenkomende veldwaarden als duplicaten moeten tellen.

sorted() gebruikt de natuurlijke volgorde. Geef een comparator op voor een andere volgorde of voor objecten zonder natuurlijke volgorde. Het sorteren van een geordende stream is stabiel. Als je de vijf studenten op aflopende punten sorteert en er twee neemt, selecteer je Dara en Ada: Ada staat in de oorspronkelijke lijst vóór Chen bij hun gelijke score. Als je limit(2) vóór het sorteren aanroept, worden alleen de oorspronkelijke eerste twee studenten bekeken.

Maak geneste reeksen vlak

List<Integer> all = List.of(
        List.of(1, 2), List.of(3), List.of(4, 5, 6))
    .stream()
    .flatMap(List::stream)
    .toList();
System.out.println(all); // [1, 2, 3, 4, 5, 6]

Elke binnenste lijst wordt een stream en flatMap voegt de elementen daarvan samen tot één stream. Als je hier flatMap vervangt door map, krijg je een Stream<Stream<Integer>>: één streamobject per binnenste lijst, zonder die vlak te maken.

peek geeft een waarde ongewijzigd door en kan die weergeven om fouten op te sporen. De actie wordt alleen uitgevoerd voor elementen die daadwerkelijk worden doorlopen en een implementatie kan een onnodige stap overslaan, bijvoorbeeld bij het optimaliseren van count. Gebruik de bewerking niet om noodzakelijk werk uit te voeren. Gebruik voor één grootste waarde max(comparator) in plaats van elk element te sorteren en er één te nemen.

Kies de eindbewerking op basis van het resultaat dat je nodig hebt: een aantal, een getal, een waarheidswaarde, één element of een algemene combinatie. Lege invoer is van belang wanneer geen resultaatwaarde kan worden gekozen.

Bereken een getal

count() geeft een long terug. sum() op een primitieve stream geeft een getal van het primitieve type van de stream terug. Voor de punten [72, 45, 90, 58, 81] geeft filteren op minstens 60 en daarna optellen de waarde 243. Het gemiddelde van die drie waarden is 81,0.

import java.util.List;

class PointResults {
    public static void main(String[] args) {
        List<Integer> points = List.of(72, 45, 90, 58, 81);
        int sum = points.stream().filter(p -> p >= 60)
            .mapToInt(Integer::intValue).sum();
        double average = points.stream().filter(p -> p >= 60)
            .mapToInt(Integer::intValue).average().orElse(0.0);
        System.out.println(sum);     // 243
        System.out.println(average); // 81.0
    }
}

De tweede verwerkingspijplijn gebruikt een nieuwe stream. Een lege som is 0, maar een gemiddelde van lege invoer heeft geen waarde. average() geeft een OptionalDouble terug en orElse(0.0) levert een gekozen terugvalwaarde. Die standaardwaarde is een keuze in het programma, niet het wiskundige gemiddelde van een lege verzameling.

Een int-som kan overlopen. Het optellen van twee waarden van 2.000.000.000 levert als int −294.967.296 op. Zet vóór het optellen om: mapToInt(...).asLongStream().sum() geeft 4.000.000.000 als een long.

Handel één waarde of geen waarde af

Een Optional<T> bevat één waarde of geen waarde. min, max, findFirst, findAny en reductie zonder neutraal element op objectstreams geven optionals terug. points.stream().max(Integer::compare) geeft Optional[90]; als je de container weergeeft, staat de tekst van de wrapper erbij.

Gebruik orElse voor een terugvalwaarde, orElseGet voor een leverancier van een terugvalwaarde, ifPresent voor een actie of map om een aanwezige waarde te transformeren. Als je filtert op een student met meer dan 95 punten, de eerste gevonden student omzet naar een naam en orElse("nobody") toepast, krijg je "nobody" voor de gegevens van de vijf studenten. get() of orElseThrow() aanroepen op een lege optional werpt een NoSuchElementException op.

Stel een waar-of-onwaarvraag

anyMatch vraagt of minstens één waarde voldoet, allMatch of elke waarde voldoet en noneMatch of geen enkele waarde voldoet. Ze kunnen stoppen zodra het antwoord bekend is. Bij lege invoer is anyMatch onwaar, terwijl allMatch en noneMatch waar zijn: er is geen waarde die een van beide algemene uitspraken schendt.

Combineer met een neutraal element

Stream.of(3, 5, 7).reduce(0, Integer::sum) bouwt de waarden 0, 3, 8, 15 op. Begin voor vermenigvuldigen met 1 en gebruik (a, b) -> a * b om 105 te krijgen. Een neutraal element laat een waarde bij de bewerking ongewijzigd; 10 is geen neutraal element voor optellen en zou het totaal ten onrechte naar 25 verschuiven. De accumulator moet associatief zijn, zodat groepering het resultaat niet verandert.

Zonder neutraal element geeft reduce(Integer::max) de waarde Optional[7] en bij lege invoer een lege optional. forEach voert daarentegen een actie uit en heeft retourtype void; het is geschikt voor weergeven. Gebruik reductie of verzamelen als de taak is om een resultaatwaarde te produceren.

Een collector zet een stream om in een bruikbare resultaatstructuur. Bepaal wat het resultaat moet ondersteunen: duplicaten, ordening, latere wijzigingen of dubbele mapsleutels. Verschillende collectors bieden verschillende garanties.

Kies een lijst of verzameling

stream.toList() geeft een niet-wijzigbare lijst in bronvolgorde terug. Elementen toevoegen of verwijderen werpt een UnsupportedOperationException op. collect(Collectors.toList()) verzamelt ook een lijst, maar garandeert geen specifieke implementatie of wijzigbaarheid. Vraag expliciet om een lijst die je gaat wijzigen:

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

class Gather {
    public static void main(String[] args) {
        List<String> words = Stream.of("a", "b", "a")
            .collect(Collectors.toCollection(ArrayList::new));
        words.add("c");
        System.out.println(words); // [a, b, a, c]
        System.out.println(Stream.of("a", "b", "a")
            .collect(Collectors.toSet()).size()); // 2
    }
}

toSet verwijdert duplicaten en garandeert geen volgorde. toCollection(TreeSet::new) vraagt om een gesorteerde verzameling. Een lijst behoudt dubbele elementen; kies een verzameling als het resultaat unieke waarden weergeeft.

Voeg tekst samen

Collectors.joining(", ") voegt strings samen met een scheidingsteken, zonder scheidingsteken aan het einde. De vorm met drie argumenten voegt ook een voorvoegsel en achtervoegsel toe:

String names = Stream.of("Ada", "Chen", "Dara")
    .collect(Collectors.joining(", ", "[", "]"));
System.out.println(names); // [Ada, Chen, Dara]

De elementen moeten CharSequence-waarden zijn, meestal strings. Zet studenten vóór het samenvoegen om met Student::getName of getallen met String::valueOf. Samenvoegen geeft één string terug, geen lijst die er bij weergave alleen vergelijkbaar uitziet.

Kies mapsleutels en -waarden

Collectors.toMap(keyFunction, valueFunction) berekent uit elk element een sleutel-waardepaar. Met de vijf studenten Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64) geeft het koppelen van namen aan punten vijf sleutel-waardeparen zoals Ada=85 en Eli=64.

Bij groepssleutels ligt dat anders: meerdere studenten hebben dezelfde groep. toMap(Student::getGroup, Student::getPoints) met twee argumenten werpt een IllegalStateException op wanneer een sleutel wordt herhaald, ook als beide waarden 85 zijn. Een map heeft één resulterende waarde per sleutel nodig en deze vorm biedt geen regel om die te kiezen.

Geef een derde argument op om duplicaten samen te voegen:

Map<String, Integer> totals = students.stream()
    .collect(Collectors.toMap(
        Student::getGroup, Student::getPoints, Integer::sum));

Groep A krijgt 85 + 85 + 64 = 234; groep B krijgt 72 + 90 = 162. Als je Integer::sum vervangt door Math::max, blijven de hoogste punten per groep behouden, A=85 en B=90. Gebruik de regel die bij de taak past, niet een willekeurige eerste waarde.

toMap garandeert geen specifieke mapvolgorde. Een vierde argument kan daarom vragen, bijvoorbeeld TreeMap::new voor gesorteerde sleutels. toMap(Student::getName, Student::getPoints, (a, b) -> a, TreeMap::new) behoudt de eerste waarde bij dubbele namen en sorteert op naam. Een collector voorkomt ook dat je een externe lijst moet maken en die binnen forEach moet wijzigen; het resultaat wordt opgebouwd door de bewerking die bedoeld is om het te verzamelen.

Een gegroepeerd resultaat beantwoordt voor elke sleutel een vraag. Een partitie beantwoordt een ja-neevraag met twee groepen. Een vervolgcollector bepaalt wat elke groep opslaat.

Groepeer op een berekende sleutel

groupingBy(classifier) maakt een map die elke aangetroffen sleutel koppelt aan een lijst met de bijbehorende elementen. Als je ["fig", "kiwi", "pear", "plum", "apple", "mango", "banana"] groepeert op woordlengte, krijgt lengte 4 de lijst [kiwi, pear, plum]. Ontbrekende lengtes hebben geen sleutel-waardepaar; als je er een opzoekt, krijg je null. Gebruik daarom getOrDefault(key, List.of()) als een lege lijst handig is.

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

class WordGroups {
    public static void main(String[] args) {
        List<String> words = List.of(
            "fig", "kiwi", "pear", "plum", "apple", "mango", "banana");
        Map<Integer, Long> counts = words.stream()
            .collect(Collectors.groupingBy(
                String::length, TreeMap::new, Collectors.counting()));
        System.out.println(counts); // {3=1, 4=3, 5=2, 6=1}
    }
}

De classificatiefunctie kiest gehele getallen als sleutels. TreeMap::new ordent die sleutels. counting() vervangt de lijst van elke groep door de grootte ervan als een Long. Het resultaattype is daarom Map<Integer, Long>, geen map van gehele getallen naar gehele getallen.

Verander wat een groep opslaat

Bij de studenten Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64) geeft groeperen op Student::getGroup deze mogelijkheden:

Een vervolgcollector werkt binnen elke groep. Voor A is het gemiddelde 234 gedeeld door 3, oftewel 78,0; het gemiddelde van B is 81,0. maxBy en minBy slaan een Optional op met het extremum van elke groep. Gewoon groupingBy garandeert geen specifiek maptype of een specifieke sleutelvolgorde; met de vorm met een mapfabriek kies je die expliciet.

Verdeel in twee antwoorden

Map<Boolean, List<String>> partition = students.stream()
    .collect(Collectors.partitioningBy(
        s -> s.getPoints() >= 80,
        Collectors.mapping(Student::getName, Collectors.toList())));

De lijst voor waar is [Ada, Chen, Dara] en de lijst voor onwaar is [Ben, Eli]. Beide booleaanse sleutels zijn aanwezig, ook als één kant geen studenten bevat. Met counting() als vervolgcollector bevatten lege kanten 0 als een Long. groupingBy met een booleaanse classificatiefunctie maakt daarentegen alleen sleutels die voorkomen.

Verwerk de map die je hebt opgebouwd

Een gegroepeerd resultaat is een gewone map. Doorloop die met forEach((group, value) -> ...) of maak een stream van de sleutel-waardeparen. Voor de gemiddelden A=78,0 en B=81,0 geeft averages.entrySet().stream().max(Map.Entry.comparingByValue()) een Optional<Map.Entry<String, Double>> terug met B=81.0. De optional bevat het winnende sleutel-waardepaar; het is niet de gewone waarde 81,0. Een afzonderlijke stap kan dat sleutel-waardepaar omzetten naar de sleutel of waarde en een lege map afhandelen.

Een volledige gegevenstaak heeft vaak twee fasen: vat de invoer samen en bevraag daarna de samenvatting. Kies streams als deze fasen natuurlijk lezen als standaardbewerkingen, en lussen als expliciete controle het werk duidelijker maakt.

Bereken gemiddelde metingen en selecteer daarna steden

Stel dat een Reading de methoden getCity() en getCelsius() heeft. De metingen zijn Oslo 4,5, Lima 19,0, Oslo 6,0, Cairo 27,5 en Lima 21,0, in graden Celsius.

class Reading {
    private final String city;
    private final double celsius;
    Reading(String city, double celsius) {
        this.city = city;
        this.celsius = celsius;
    }
    String getCity() { return city; }
    double getCelsius() { return celsius; }
}

Maak de invoerlijst vóór beide implementaties:

List<Reading> readings = List.of(
    new Reading("Oslo", 4.5), new Reading("Lima", 19.0),
    new Reading("Oslo", 6.0), new Reading("Cairo", 27.5),
    new Reading("Lima", 21.0));

Map<String, Double> averages = readings.stream()
    .collect(Collectors.groupingBy(
        Reading::getCity,
        TreeMap::new,
        Collectors.averagingDouble(Reading::getCelsius)));

List<String> warmCities = averages.entrySet().stream()
    .filter(e -> e.getValue() > 15)
    .map(Map.Entry::getKey)
    .toList();

Het eerste resultaat is {Cairo=27.5, Lima=20.0, Oslo=5.25}. Het gemiddelde van Oslo is (4.5 + 6.0) / 2, oftewel 5,25. Dat van Lima is 20,0. Het tweede resultaat is [Cairo, Lima]; de TreeMap zorgt voor een oplopende volgorde van steden. Filter de gemiddelden na het groeperen: als je eerst afzonderlijke metingen filtert, beantwoord je een andere vraag.

Gebruik voor de warmste afzonderlijke meting readings.stream().max(Comparator.comparingDouble(Reading::getCelsius)). Dit geeft een optional met de meting van Cairo terug, niet per definitie de stad met het warmste gemiddelde. Die taken kunnen bij andere gegevens verschillende antwoorden opleveren.

Druk dezelfde berekening uit met lussen

Map<String, List<Double>> byCity = new TreeMap<>();
for (Reading r : readings) {
    byCity.computeIfAbsent(r.getCity(), k -> new ArrayList<>())
        .add(r.getCelsius());
}
Map<String, Double> averages = new TreeMap<>();
for (Map.Entry<String, List<Double>> e : byCity.entrySet()) {
    double sum = 0;
    for (double value : e.getValue()) sum += value;
    averages.put(e.getKey(), sum / e.getValue().size());
}
System.out.println(averages);
// {Cairo=27.5, Lima=20.0, Oslo=5.25}

Dit zijn alternatieve implementaties van hetzelfde resultaat; elke groep is niet-leeg omdat een meting die heeft gemaakt. De stream maakt het groeperen en het gemiddelde expliciet in één collector. De lussen laten de tussenliggende lijsten en de som zien.

Houd verwerkingsgedrag voorspelbaar

Een lambda-expressie in een verwerkingspijplijn hoort te rekenen met haar invoer zonder externe toestand te wijzigen. Voor de punten [72, 45, 90, 58, 81] levert filter(p -> p >= 60).toList() rechtstreeks [72, 90, 81] op. Als je binnen forEach aan een externe lijst toevoegt, verberg je het opbouwen van het resultaat in een actie.

Wijzig een ArrayList-bron niet binnen de eigen verwerkingspijplijn: elementen toevoegen vanuit een forEach kan een ConcurrentModificationException opwerpen. Verzamel nieuwe elementen eerst afzonderlijk en voeg die pas toe nadat de verwerking is voltooid. De typeregels van Java kunnen mutatie via een vastgelegde final-referentie toestaan; dat maakt mutatie binnen een stream nog niet geschikt.

Kies de duidelijkste besturingsstroom

Gebruik een lus wanneer je naast elkaar liggende indexen, een ingewikkelde stopvoorwaarde of meerdere onderling afgestemde bijwerkingen nodig hebt. Gebruik streams voor een leesbare selectie, transformatie en verzameling. Streamsyntaxis alleen biedt geen snelheidsgarantie. Geef een lang predicaat of een lange comparator een naam en splits een lange keten bij een betekenisvol tussenresultaat. Inspecteer bij het opsporen van fouten met peek of verzamel een tussenstap in een lijst en geef die weer; ga verder met een nieuwe stream van die lijst in plaats van een verbruikte verwerkingspijplijn opnieuw te gebruiken.