PricingLoginStart free
Java Academy · Lektion

groupingBy: klassificering af elementer

Gruppér stream-elementer i maps efter en klassificeringsfunktion, og kombinér med efterfølgende collectors.

Lektion 1 af 413 trin

groupingBy: klassificering af elementer er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad er groupingBy?

Collectors.groupingBy() opdeler elementerne i et stream i en Map, hvor hver nøgle knyttes til en liste med matchende elementer. Det svarer til SQL's GROUP BY for streams.

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

Sammensæt groupingBy med en nedstrøms-collector for at aggregere i stedet for at opliste:

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

Brug Collectors.mapping() som nedstrøms-collector til at transformere elementer, før de indsamles:

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

Sammenkæd navnene i hver gruppe til én kommasepareret 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

groupingBy på flere niveauer

Nest groupingBy-kald for at klassificere efter flere dimensioner:

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())));

Styring af Map-typen

Som standard producerer groupingBy en HashMap. Brug den overbelastede version med tre argumenter til at angive en anden Map-type, f.eks. TreeMap til sorterede nøgler:

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 gennemsnit pr. 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

Brug Collectors.toUnmodifiableList() som nedstrøms-collector for at oprette 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 anvendelse: Opsummering af ordrer

Gruppér ordrer efter status, og beregn summen af beløbene for hver 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));

Ydelsesmæssige overvejelser

groupingBy indsamler alle elementer i hukommelsen. Overvej at behandle meget store datasæt i blokke eller bruge en databasebaseret GROUP BY. Den nedstrøms-collector køres for hvert element — hold den let for at undgå O(n²)-adfærd.

Kombination med filter og sorted

Kæd stream-operationer sammen før indsamlingen for at filtrere eller sortere data på forhånd:

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}

Hurtigt tjek

Hvilken type producerer Collectors.groupingBy(Person::city), når den bruges sammen med collect()?

Besvar den i den interaktive lektion

Opsummering: groupingBy

Vigtigste pointer:

  • groupingBy(classifier) → Map<K, List<T>>
  • Sammensæt med nedstrøms-collectors: counting, mapping, joining, summarizing
  • Nest groupingBy for at klassificere efter flere dimensioner
  • Brug versionen med tre argumenter til at styre den resulterende Map-type (f.eks. TreeMap)
Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
104
Lektioner
374
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “groupingBy: klassificering af elementer” gratis?

Ja — hele teksten til “groupingBy: klassificering af elementer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “groupingBy: klassificering af elementer”?

Gruppér stream-elementer i maps efter en klassificeringsfunktion, og kombinér med efterfølgende collectors. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “groupingBy: klassificering af elementer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. groupingBy: klassificering af elementer
  2. partitioningBy og counting
  3. toMap, joining og summarizing
  4. Opbygning af en brugerdefineret collector
← Tilbage til Java Academy