PricingLoginStart free
Java Academy · Lekcja

IntStream i LongStream

Unikanie opakowywania wartości w strumieniach

Lekcja 1 z 413 kroki

IntStream i LongStream to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 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.

Dlaczego istnieją strumienie prymitywne

Stream<Integer> opakowuje każdy element w obiekt typu Integer. IntStream, LongStream i DoubleStream operują bezpośrednio na prymitywach, aby uniknąć narzutu związanego z boxingiem.

import java.util.stream.IntStream;

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

Tworzenie IntStream

Użyj IntStream.of dla jawnie podanych wartości albo Arrays.stream dla tablicy int[].

import java.util.Arrays;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int[] data = {10, 20, 30};
        IntStream s = Arrays.stream(data);
        System.out.println(s.max().getAsInt());
    }
}

LongStream dla dużych liczb

LongStream działa podobnie jak IntStream, ale operuje na wartościach typu long, zapobiegając przepełnieniu przy obliczaniu dużych sum.

import java.util.stream.LongStream;

public class Main {
    public static void main(String[] args) {
        long total = LongStream.of(1_000_000_000L, 2_000_000_000L).sum();
        System.out.println(total);
    }
}

Wyspecjalizowane operacje końcowe

Strumienie prymitywne udostępniają metody numeryczne, których brakuje strumieniom obiektów: sum, min, max i average.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream nums = IntStream.of(4, 8, 15, 16, 23, 42);
        System.out.println(nums.average().getAsDouble());
    }
}

Wyniki OptionalInt

min i max zwracają OptionalInt, ponieważ strumień może być pusty. Należy użyć getAsInt albo orElse.

import java.util.OptionalInt;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        OptionalInt result = IntStream.empty().max();
        System.out.println(result.orElse(-1));
    }
}

map pozostaje typem prymitywnym

map na obiekcie IntStream przyjmuje IntUnaryOperator i zwraca kolejny IntStream, więc nie dochodzi do boxingowania.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sumOfSquares = IntStream.of(1, 2, 3)
            .map(n -> n * n)
            .sum();
        System.out.println(sumOfSquares);
    }
}

filter w strumieniach prymitywnych

filter przyjmuje IntPredicate i zachowuje pasujące wartości prymitywne.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long evens = IntStream.of(1, 2, 3, 4, 5, 6)
            .filter(n -> n % 2 == 0)
            .count();
        System.out.println(evens);
    }
}

reduce na IntStream

reduce redukuje strumień za pomocą IntBinaryOperator. Przy podaniu wartości początkowej zwraca bezpośrednio wartość typu int.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int product = IntStream.rangeClosed(1, 5)
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

forEach dla prymitywów

forEach przyjmuje IntConsumer, ponownie unikając boxingowania.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.of(7, 8, 9).forEach(n -> System.out.println(n));
    }
}

Zbieranie do tablicy

toArray zwraca prymitywną tablicę int[], czyli naturalny odpowiednik IntStream.

import java.util.Arrays;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int[] doubled = IntStream.of(1, 2, 3).map(n -> n * 2).toArray();
        System.out.println(Arrays.toString(doubled));
    }
}

Konwersja między IntStream i LongStream

IntStream.asLongStream poszerza typy prymitywne do long bez boxingowania.

import java.util.stream.IntStream;

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

Szybkie sprawdzenie

Jaki jest główny powód używania IntStream zamiast Stream<Integer>?

Odpowiedz w interaktywnej lekcji

Podsumowanie

Użyto strumieni prymitywnych, aby uniknąć boxingowania:

  • IntStream i LongStream przechowują bezpośrednio prymitywy.
  • Udostępniają numeryczne operacje końcowe: sum, min, max i average.
  • min i max zwracają OptionalInt.
  • map, filter, reduce i toArray zachowują typy prymitywne.
Bezpłatny start

Ucz się Java dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
104
Lekcje
374
Zacznij naukę bezpłatnieWyświetl pełny kurs

Często zadawane pytania

Czy lekcja „IntStream i LongStream” jest bezpłatna?

Tak — pełny tekst „IntStream i LongStream” 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 „IntStream i LongStream”?

Unikanie opakowywania wartości w strumieniach Ć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 1 z 4.

Ile czasu zajmuje lekcja „IntStream i LongStream”?

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

  1. IntStream i LongStream
  2. Operacje na zakresach i agregowanie
  3. Mapowanie do strumieni obiektów i z nich
  4. Generowanie strumieni typów prostych
← Powrót do Java Academy