Java Academy · leksjon

groupingBy: klassifisere elementer

Gruppér strøm elementer i kart ved hjelp av en klassifiseringsfunksjon, og kombiner med etterfølgende samlingsoperasjoner.

Leksjon 1 av 413 trinn

groupingBy: klassifisere elementer er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva er groupingBy?

Collectors.groupingBy() deler strømelementer inn i en Map der hver nøkkel peker på en liste med samsvarende elementer. Det tilsvarer GROUP BY i SQL.

import java.util.*;
import java.util.stream.*;

record Person(String name, String city) {}
List<Person> people = List.of(
    new Person("Alice","NYC"), new Person("Bob","LA"),
    new Person("Carol","NYC"), new Person("Dave","LA"),
    new Person("Eve","Chicago")
);

Map<String, List<Person>> byCity =
    people.stream().collect(Collectors.groupingBy(Person::city));
byCity.forEach((city, ps) -> System.out.println(city + ": " + ps.size()));

Nedstrøms collector: counting

Kombiner groupingBy med en nedstrøms collector for å aggregere i stedet for å liste opp elementer:

Map<String, Long> countByCity =
    people.stream().collect(
        Collectors.groupingBy(Person::city, Collectors.counting())
    );
countByCity.forEach((city, n) -> System.out.println(city + " -> " + n));
// NYC -> 2, LA -> 2, Chicago -> 1

Nedstrøms collector: mapping

Bruk Collectors.mapping() som nedstrøms collector for å transformere elementer før de samles inn:

Map<String, List<String>> namesByCity =
    people.stream().collect(
        Collectors.groupingBy(
            Person::city,
            Collectors.mapping(Person::name, Collectors.toList())
        )
    );
namesByCity.forEach((city, names) -> System.out.println(city + ": " + names));

Nedstrøms collector: joining

Slå sammen navn per gruppe til én kommaseparert tekststreng:

Map<String, String> joinedByCity =
    people.stream().collect(
        Collectors.groupingBy(
            Person::city,
            Collectors.mapping(Person::name, Collectors.joining(", "))
        )
    );
joinedByCity.forEach((city, s) -> System.out.println(city + ": " + s));
// NYC: Alice, Carol

Gruppering på flere nivåer med groupingBy

Nest groupingBy-kall for klassifisering langs flere dimensjoner:

record Employee(String name, String dept, String level) {}
List<Employee> emps = List.of(
    new Employee("A","Eng","Junior"), new Employee("B","Eng","Senior"),
    new Employee("C","HR","Junior"), new Employee("D","HR","Senior")
);

Map<String, Map<String, List<Employee>>> grouped =
    emps.stream().collect(
        Collectors.groupingBy(Employee::dept,
            Collectors.groupingBy(Employee::level))
    );
grouped.forEach((dept, levels) -> levels.forEach((level, list) ->
    System.out.println(dept+"/"+level+": "+list.size())));

Kontrollere Map-typen

Som standard produserer groupingBy en HashMap. Bruk overlastingen med tre argumenter for å angi en annen map-type, for eksempel TreeMap for sorterte nøkler:

Map<String, Long> sorted =
    people.stream().collect(
        Collectors.groupingBy(Person::city, TreeMap::new, Collectors.counting())
    );
System.out.println(sorted); // keys in alphabetical order

Nedstrøms: averagingInt

Beregn gjennomsnitt per gruppe:

record Product(String category, int price) {}
List<Product> products = List.of(
    new Product("A",10), new Product("A",20),
    new Product("B",15), new Product("B",25)
);

Map<String, Double> avgPrice =
    products.stream().collect(
        Collectors.groupingBy(Product::category,
            Collectors.averagingInt(Product::price))
    );
avgPrice.forEach((cat, avg) -> System.out.printf("%s: %.1f%n", cat, avg));

Nedstrøms: toUnmodifiableList

Bruk Collectors.toUnmodifiableList() som nedstrøms collector for å opprette uforanderlige grupper:

Map<String, List<String>> immutable =
    people.stream().collect(
        Collectors.groupingBy(Person::city,
            Collectors.mapping(Person::name, Collectors.toUnmodifiableList()))
    );
// Attempting to modify throws UnsupportedOperationException

Praktisk bruk: Ordresammendrag

Gruppér ordrer etter status og summer beløpene per gruppe:

record Order(String status, double amount) {}
List<Order> orders = List.of(
    new Order("PAID", 50.0), new Order("PENDING", 30.0),
    new Order("PAID", 75.0), new Order("CANCELLED", 20.0)
);

Map<String, Double> totalByStatus =
    orders.stream().collect(
        Collectors.groupingBy(Order::status,
            Collectors.summingDouble(Order::amount))
    );
totalByStatus.forEach((s, t) -> System.out.printf("%s: $%.2f%n", s, t));

Ytelsesbetraktninger

groupingBy samler alle elementer i minnet. For svært store datasett bør du vurdere å behandle dataene i deler eller bruke GROUP BY på databasenivå. Den nedstrøms collectoren kjøres for hvert element – hold den enkel for å unngå O(n²)-oppførsel.

Kombinere med filter og sorted

Kjed sammen strømelementer før innsamling for å forhåndsfiltrere eller forhåndssortere dataene:

Map<String, Long> activeCities =
    people.stream()
          .filter(p -> !p.city().equals("Chicago"))
          .collect(Collectors.groupingBy(Person::city, Collectors.counting()));
System.out.println(activeCities); // {NYC=2, LA=2}

Hurtigsjekk

Hvilken type produserer Collectors.groupingBy(Person::city) når den brukes sammen med collect()?

Besvar den i den interaktive leksjonen

Oppsummering: groupingBy

Viktigste punkter:

groupingBy(classifier) → Map<K, List<T>>
Kombiner med nedstrøms collectorer: counting, mapping, joining og summarizing
Nest groupingBy for klassifisering langs flere dimensjoner
Bruk overlastingen med tre argumenter for å kontrollere typen på det resulterende map-et, for eksempel TreeMap

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «groupingBy: klassifisere elementer» gratis?

Ja – hele teksten i «groupingBy: klassifisere elementer» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «groupingBy: klassifisere elementer»?

Gruppér strøm elementer i kart ved hjelp av en klassifiseringsfunksjon, og kombiner med etterfølgende samlingsoperasjoner. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «groupingBy: klassifisere elementer»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Java Academy