Java Academy · Lekcja

Mapowanie do strumieni obiektów i z nich

mapToObj i mapToInt

Mapowanie do strumieni obiektów i z nich to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Dwa światy strumieni

Java udostępnia strumienie obiektów (Stream<T>) oraz strumienie prymitywne (IntStream i podobne). Metody mapowania pozwalają przechodzić między tymi rodzajami strumieni.

import java.util.stream.IntStream;

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

mapToObj: od prymitywu do obiektu

mapToObj konwertuje każdy prymityw na obiekt, tworząc 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: od obiektu do prymitywu

mapToInt pobiera wartość typu int z każdego obiektu, tworząc IntStream gotowy do agregacji numerycznej.

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: od prymitywu do strumienia wrapperów

boxed przekształca IntStream w Stream<Integer>, którego potrzebują Państwo przed zebraniem elementów do listy typu 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 i mapToDouble

Ten sam wzorzec dotyczy innych prymitywów: mapToLong i 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);
    }
}

Dlaczego mapToInt jest lepsze od map

Użycie map na strumieniu obiektów zachowuje boxing. mapToInt udostępnia metody numeryczne, takie jak sum i average, jednocześnie unikając boxingowania.

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

Podróż w obie strony: od obiektu do IntStream i z powrotem

W jednym potoku można przejść w obu kierunkach: wyodrębnić liczby, przekształcić je, a następnie ponownie zmapować na obiekty.

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

W obrębie strumieni prymitywnych można poszerzać typy: asLongStream i asDoubleStream zmieniają zakres liczbowy bez boxingowania.

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

Zbieranie wyników prymitywnych

Aby zebrać prymitywy do kolekcji, należy najpierw wywołać boxed, a następnie użyć kolektora.

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 spłaszcza obiekty do jednego IntStream, co jest przydatne, gdy każdy obiekt dostarcza wiele liczb.

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

Wybór właściwego mapowania

Należy wybrać metodę zależnie od kierunku:

Od obiektu do prymitywu: mapToInt, mapToLong, mapToDouble.
Od prymitywu do obiektu: mapToObj lub 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);
    }
}

Szybkie sprawdzenie

Która metoda przekształca IntStream w Stream<Integer>?

Podsumowanie

Przechodzono między strumieniami obiektów i prymitywów:

mapToInt/mapToLong/mapToDouble konwertują obiekty na prymitywy.
mapToObj i boxed konwertują prymitywy na obiekty.
flatMapToInt spłaszcza wiele liczb do jednego IntStream.
Przejście do strumieni prymitywnych udostępnia agregacje numeryczne bez boxingowania.

Często zadawane pytania

Czy lekcja „Mapowanie do strumieni obiektów i z nich” jest bezpłatna?

Tak — pełny tekst „Mapowanie do strumieni obiektów i z nich” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Mapowanie do strumieni obiektów i z nich”?

mapToObj i mapToInt Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Mapowanie do strumieni obiektów i z nich”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

IntStream i LongStream
Operacje na zakresach i agregowanie
Mapowanie do strumieni obiektów i z nich
Generowanie strumieni typów prostych

← Powrót do Java Academy