PricingLoginStart free
Java Academy · leksjon

flatMap for nestede samlinger

Flat ut nestede lister, Optional-kjeder og fil-linjestrukturer ved hjelp av flatMap.

Leksjon 1 av 413 trinn

flatMap for nestede samlinger 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.

Problemet med nestede samlinger

Når hvert element i en strøm avbilder til en annen samling, gir map deg en Stream<List<T>>. flatMap slår sammen de indre strømmene til én flat Stream<T>.

List<List<Integer>> nested = List.of(List.of(1,2), List.of(3,4), List.of(5));
// With map:
Stream<List<Integer>> s = nested.stream().map(l -> l); // Stream<List<Integer>>
// With flatMap:
Stream<Integer> flat = nested.stream().flatMap(List::stream); // Stream<Integer>
flat.forEach(System.out::println); // 1 2 3 4 5

flatMap kontra map

map(f) bruker f på hvert element og pakker inn resultatet. flatMap(f) bruker f, som returnerer en strøm, og setter deretter alle disse strømmene sammen til én.

// map: List<String> -> Stream<Stream<Character>>
Stream<Stream<Character>> nested = List.of("hi","bye").stream()
    .map(s -> s.chars().mapToObj(c -> (char)c));
// flatMap: List<String> -> Stream<Character>
Stream<Character> flat = List.of("hi","bye").stream()
    .flatMap(s -> s.chars().mapToObj(c -> (char)c));

Flate ut ordre og varer

Et klassisk bruksområde: Hver ordre har en liste over varer. Hent en flat strøm med alle varene fra alle ordrene.

List<String> allItems = orders.stream()
    .flatMap(order -> order.getItems().stream())
    .collect(Collectors.toList());
System.out.println(allItems);

flatMap med Optional

Bruk stream() på Optional (Java 9+) for å konvertere den til en strøm med 0 eller 1 element. Deretter slår flatMap en Stream<Optional<T>> sammen til Stream<T>.

List<Optional<String>> maybes = List.of(Optional.of("a"), Optional.empty(), Optional.of("c"));
List<String> values = maybes.stream()
    .flatMap(Optional::stream)  // Java 9+
    .collect(Collectors.toList());
System.out.println(values); // [a, c]

Lese alle linjer fra flere filer

flatMap gjør det enkelt å sette sammen alle linjene fra en liste med filer til én strøm, uten nestede løkker.

List<Path> files = List.of(Path.of("a.txt"), Path.of("b.txt"));
List<String> allLines = files.stream()
    .flatMap(p -> {
        try { return Files.lines(p); }
        catch (IOException e) { return Stream.empty(); }
    })
    .collect(Collectors.toList());

Dele strenger i ord

Del hver setning i ord, og flat ut alle ordene til én strøm for å telle ordfrekvenser.

List<String> sentences = List.of("hello world", "java streams rock");
Map<String, Long> freq = sentences.stream()
    .flatMap(s -> Arrays.stream(s.split("\\s+")))
    .collect(Collectors.groupingBy(w -> w, Collectors.counting()));
System.out.println(freq);

flatMap med Map.entrySet

Flat ut et kart fra kategorier til lister med elementer til en strøm med alle elementene.

Map<String, List<String>> catalog = Map.of(
    "fruit", List.of("apple","banana"),
    "veg",   List.of("carrot","pea"));
List<String> all = catalog.values().stream()
    .flatMap(List::stream)
    .sorted()
    .collect(Collectors.toList());
System.out.println(all); // [apple, banana, carrot, pea]

Unngå NullPointerException i flatMap

Hvis funksjonen kan returnere null i stedet for en strøm, bør du kontrollere om verdien er null, eller returnere Stream.empty() for å unngå NullPointerException.

departments.stream()
    .flatMap(dept -> dept.getEmployees() == null
        ? Stream.empty()
        : dept.getEmployees().stream())
    .forEach(System.out::println);

Telle unike ord med flatMap

Kombiner flatMap, distinct og count for kortfattet databehandling.

long distinctWords = sentences.stream()
    .flatMap(s -> Arrays.stream(s.toLowerCase().split("[^a-z]+")))
    .filter(w -> !w.isEmpty())
    .distinct()
    .count();
System.out.println("Distinct: " + distinctWords);

flatMapToInt for primitive strømmer

Bruk flatMapToInt, flatMapToLong og flatMapToDouble for å unngå boxing når du flater ut til primitive strømmer.

int totalQuantity = orders.stream()
    .flatMapToInt(order -> order.getItems().stream().mapToInt(Item::getQuantity))
    .sum();
System.out.println("Total qty: " + totalQuantity);

Ytelsesmerknad

Hvert kall på flatMap legger til et strømlag. For svært store datasett med mange små indre samlinger bør du vurdere iterative tilnærminger eller Spliterator for å redusere overhead fra objektoppretting.

Kort kontroll

Hva gjør flatMap annerledes enn map?

Besvar den i den interaktive leksjonen

Oppsummering

flatMap konverterer hvert element til en strøm og slår alle strømmene sammen til én. Bruk den til å flate ut nestede samlinger, kjede sammen Optionals, dele strenger og lese flere filer. Bruk flatMapToInt for å unngå boxing.

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 gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «flatMap for nestede samlinger» gratis?

Ja – hele teksten i «flatMap for nestede samlinger» 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 «flatMap for nestede samlinger»?

Flat ut nestede lister, Optional-kjeder og fil-linjestrukturer ved hjelp av flatMap. 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 «flatMap for nestede samlinger»?

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

  1. flatMap for nestede samlinger
  2. Parallelle strømmer: ytelse og fallgruver
  3. Spliterator: oppdeling for parallellitet
  4. Uendelige strømmer med iterate og generate
← Tilbake til Java Academy