Java Academy · Lektion

Zu und von Object-Streams abbilden

mapToObj und mapToInt

Zu und von Object-Streams abbilden ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Zwei Stream-Welten

Java verfügt über Objekt-Streams (Stream<T>) und primitive Streams (IntStream und verwandte Streams). Mapping-Methoden ermöglichen den Wechsel zwischen ihnen.

import java.util.stream.IntStream;

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

mapToObj: Von primitiv zu Objekt

mapToObj wandelt jedes primitive Element in ein Objekt um und erzeugt einen 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: Von Objekt zu primitiv

mapToInt extrahiert aus jedem Objekt einen int-Wert und erzeugt einen IntStream, der für numerische Aggregationen bereit ist.

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: Von primitiv zu Wrapper-Stream

boxed wandelt einen IntStream in einen Stream<Integer> um, den Sie benötigen, bevor Sie Werte in eine List sammeln.

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 und mapToDouble

Dasselbe Muster gilt für andere primitive Typen: mapToLong und 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);
    }
}

Warum mapToInt besser als map ist

Wenn Sie map für einen Objekt-Stream verwenden, bleiben die Werte verpackt. mapToInt erschließt numerische Methoden wie sum und average und vermeidet gleichzeitig Boxing.

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

Hin und zurück: Von Objekt zu Int zu Objekt

Sie können sich innerhalb einer Pipeline in beide Richtungen bewegen: Zahlen extrahieren, transformieren und anschließend wieder auf Objekte abbilden.

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 und asDoubleStream

Innerhalb primitiver Streams können Sie Typen erweitern: asLongStream und asDoubleStream vermeiden Boxing, während sie die numerische Breite ändern.

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

Primitive Ergebnisse sammeln

Um primitive Werte in einer Collection zu sammeln, rufen Sie zuerst boxed und anschließend einen Collector auf.

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 flacht Objekte zu einem einzigen IntStream ab und ist nützlich, wenn jedes Objekt mehrere Zahlen liefert.

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

Den richtigen Mapper auswählen

Wählen Sie anhand der Richtung:

Objekt zu primitiv: mapToInt, mapToLong, mapToDouble.
Primitiv zu Objekt: mapToObj oder 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);
    }
}

Schnelltest

Welche Methode wandelt einen IntStream in einen Stream<Integer> um?

Zusammenfassung

Sie haben zwischen Objekt- und primitiven Streams gewechselt:

mapToInt/mapToLong/mapToDouble wandeln Objekte in primitive Werte um.
mapToObj und boxed wandeln primitive Werte in Objekte um.
flatMapToInt flacht viele Zahlen zu einem einzigen IntStream ab.
Der Wechsel zu primitiven Streams ermöglicht numerische Aggregationen ohne Boxing.

Häufig gestellte Fragen

Ist die Lektion „Zu und von Object-Streams abbilden“ kostenlos?

Ja — der vollständige Text von „Zu und von Object-Streams abbilden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Zu und von Object-Streams abbilden“?

mapToObj und mapToInt Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Zu und von Object-Streams abbilden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy