PricingLoginStart free
Java Academy · Lektion

flatMap för nästlade samlingar

Platta ut nästlade listor, Optional-kedjor och filradstrukturer med flatMap.

Lektion 1 av 413 steg

flatMap för nästlade samlingar är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Problemet med nästlade samlingar

När varje element i en stream mappas till en annan samling ger map dig en Stream<List<T>>. flatMap slår ihop de inre strömmarna till en enda platt 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) tillämpar f på varje element och omsluter resultatet. flatMap(f) tillämpar f, som returnerar en stream, och sammanfogar sedan alla dessa strömmar till en enda.

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

Platta ut ordrar och artiklar

Ett klassiskt användningsfall: varje order har en lista med artiklar. Hämta en platt stream med alla artiklar från alla ordrar.

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

flatMap med Optional

Använd stream() på Optional (Java 9+) för att konvertera det till en stream med 0 eller 1 element. Sedan slår flatMap ihop en Stream<Optional<T>> till 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]

Läsa alla rader från flera filer

flatMap gör det enkelt att sammanfoga alla rader från en lista med filer till en enda stream utan nästlade loopar.

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

Dela upp strängar i ord

Dela upp varje mening i ord och platta ut alla ord till en enda stream för att räkna 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

Platta ut en map från kategorier till listor med artiklar till en stream med alla artiklar.

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]

Undvika NullPointerException i flatMap

Om funktionen kan returnera null i stället för en stream, skydda med en null-kontroll eller returnera Stream.empty() för att undvika NullPointerException.

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

Räkna unika ord med flatMap

Kombinera flatMap, distinct och count för koncis databearbetning.

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 för primitiva strömmar

Använd flatMapToInt, flatMapToLong och flatMapToDouble för att undvika boxing när data plattas ut till primitiva strömmar.

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

Prestandaanmärkning

Varje anrop till flatMap lägger till ett streamlager. För mycket stora datamängder med många små inre samlingar kan iterativa lösningar eller Spliterator minska kostnaden för att skapa objekt.

Snabbkontroll

Vad gör flatMap annorlunda än map?

Besvara frågan i den interaktiva lektionen

Sammanfattning

flatMap konverterar varje element till en stream och sammanfogar alla strömmar till en enda. Använd det för att platta ut nästlade samlingar, kedja Optionals, dela upp strängar och läsa flera filer. Använd flatMapToInt för att undvika boxing.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
104
Lektioner
374
Börja lära dig gratisVisa hela kursen

Vanliga frågor

Är lektionen ”flatMap för nästlade samlingar” gratis?

Ja – hela texten till ”flatMap för nästlade samlingar” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”flatMap för nästlade samlingar”?

Platta ut nästlade listor, Optional-kedjor och filradstrukturer med flatMap. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”flatMap för nästlade samlingar”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. flatMap för nästlade samlingar
  2. Parallella strömmar: prestanda och fallgropar
  3. Spliterator: uppdelning för parallellism
  4. Oändliga strömmar med iterate och generate
← Tillbaka till Java Academy