Java Academy · Lektion

Mappa till och från objektströmmar

mapToObj och mapToInt.

Lektion 3 av 413 steg

Mappa till och från objektströmmar är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 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.

Två strömvärldar

Java har objektströmmar (Stream<T>) och primitiva strömmar (IntStream och motsvarande typer). Mappningsmetoder gör att du kan växla mellan dem.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        System.out.println(IntStream.rangeClosed(1, 3).sum());
    }
}

mapToObj: från primitivt värde till objekt

mapToObj konverterar varje primitivt värde till ett objekt och producerar en Stream<T>.

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

public class Main {
    public static void main(String[] args) {
        List<String> labels = IntStream.rangeClosed(1, 3)
            .mapToObj(n -> "item-" + n)
            .collect(Collectors.toList());
        System.out.println(labels);
    }
}

mapToInt: från objekt till primitivt värde

mapToInt hämtar en int från varje objekt och ger en IntStream som är redo för numerisk aggregering.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("hi", "hello", "hey");
        int totalChars = words.stream()
            .mapToInt(String::length)
            .sum();
        System.out.println(totalChars);
    }
}

boxed: från primitiv till wrapperström

boxed omvandlar en IntStream till en Stream<Integer>, vilket behövs innan du samlar resultatet i en List.

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

public class Main {
    public static void main(String[] args) {
        List<Integer> list = IntStream.rangeClosed(1, 5)
            .boxed()
            .collect(Collectors.toList());
        System.out.println(list);
    }
}

mapToLong och mapToDouble

Samma mönster gäller för andra primitiva typer: mapToLong och mapToDouble.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> prices = List.of("9.99", "19.50", "4.25");
        double total = prices.stream()
            .mapToDouble(Double::parseDouble)
            .sum();
        System.out.println(total);
    }
}

Varför mapToInt är bättre än map

Om du använder map på en objektström förblir värdena boxade. mapToInt ger tillgång till numeriska metoder som sum och average samtidigt som boxing undviks.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(10, 20, 30);
        double avg = nums.stream()
            .mapToInt(Integer::intValue)
            .average()
            .getAsDouble();
        System.out.println(avg);
    }
}

Tur och retur: från objekt till Int och tillbaka till objekt

Du kan gå åt båda hållen i en och samma pipeline: hämta ut tal, transformera dem och mappa sedan tillbaka till objekt.

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

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("a", "bb", "ccc");
        List<String> report = words.stream()
            .mapToInt(String::length)
            .mapToObj(len -> "len=" + len)
            .collect(Collectors.toList());
        System.out.println(report);
    }
}

asLongStream och asDoubleStream

I primitiva strömmar kan du bredda typer: asLongStream och asDoubleStream undviker boxing samtidigt som den numeriska bredden ändras.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        double avg = IntStream.of(1, 2, 3, 4)
            .asDoubleStream()
            .average()
            .getAsDouble();
        System.out.println(avg);
    }
}

Samla primitiva resultat

Om du vill samla primitiva värden i en samling anropar du först boxed och därefter en collector.

import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        Set<Integer> evens = IntStream.rangeClosed(1, 10)
            .filter(n -> n % 2 == 0)
            .boxed()
            .collect(Collectors.toSet());
        System.out.println(evens);
    }
}

flatMapToInt

flatMapToInt plattar ut objekt till en enda IntStream och är användbar när varje objekt ger upphov till flera tal.

import java.util.List;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        List<int[]> rows = List.of(new int[]{1, 2}, new int[]{3, 4});
        int sum = rows.stream()
            .flatMapToInt(Arrays::stream)
            .sum();
        System.out.println(sum);
    }
}

Välj rätt mappningsmetod

Välj utifrån riktningen:

Objekt till primitivt värde: mapToInt, mapToLong och mapToDouble.
Primitivt värde till objekt: mapToObj eller boxed.

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

public class Main {
    public static void main(String[] args) {
        List<String> in = List.of("x", "yy");
        String out = in.stream()
            .mapToInt(String::length)
            .mapToObj(Integer::toString)
            .collect(Collectors.joining(","));
        System.out.println(out);
    }
}

Snabbkontroll

Vilken metod omvandlar en IntStream till en Stream<Integer>?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du växlade mellan objektströmmar och primitiva strömmar:

mapToInt/mapToLong/mapToDouble går från objekt till primitivt värde.
mapToObj och boxed går från primitivt värde till objekt.
flatMapToInt plattar ut många tal till en enda IntStream.
Genom att gå över till primitiva strömmar får du tillgång till numeriska aggregat utan 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 gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Mappa till och från objektströmmar” gratis?

Ja – hela texten till ”Mappa till och från objektströmmar” 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 ”Mappa till och från objektströmmar”?

mapToObj och mapToInt. 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 3 av 4.

Hur lång tid tar lektionen ”Mappa till och från objektströmmar”?

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

← Tillbaka till Java Academy