0Pricing
Java Academy · Lekcja

Nieskończone strumienie za pomocą iterate i generate

Proszę tworzyć nieskończone strumienie za pomocą Stream.iterate i Stream.generate, a następnie zatrzymywać je przez limit lub take-while.

Nieskończone strumienie za pomocą iterate i generate to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 4 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.

Czym są nieskończone strumienie?

Strumienie Java mogą być nieskończone — generują elementy na żądanie i nie mają końca. Aby uniknąć wykonywania w nieskończoność, należy zakończyć je operacją ograniczającą (limit, takeWhile, findFirst itp.).

Stream.iterate: sekwencje z wartością początkową

Stream.iterate(seed, f) generuje nieskończony strumień, wielokrotnie stosując f do poprzedniej wartości. Pierwszym elementem jest wartość początkowa.

// Infinite even numbers: 0, 2, 4, 6, 8, ...
Stream.iterate(0, n -> n + 2)
    .limit(10)
    .forEach(System.out::println);

iterate z predykatem (Java 9+)

Stream.iterate(seed, predicate, f) dodaje warunek zatrzymania — podobnie jak pętla for z warunkiem. Strumień zatrzymuje się, gdy predykat ma wartość false.

// Equivalent to: for (int i = 1; i <= 100; i *= 2)
Stream.iterate(1, n -> n <= 100, n -> n * 2)
    .forEach(System.out::println); // 1 2 4 8 16 32 64

Stream.generate: generator bezstanowy

Stream.generate(Supplier) wywołuje supplier dla każdego elementu. Supplier może być bezstanowy (liczby losowe) lub stanowy (korzystający z zewnętrznego licznika).

// Infinite random doubles between 0.0 and 1.0:
Stream.generate(Math::random)
    .limit(5)
    .forEach(System.out::println);

Generowanie identyfikatorów UUID

Należy użyć generate wraz z UUID::randomUUID, aby utworzyć strumień unikatowych identyfikatorów na potrzeby generowania identyfikatorów wsadowych.

List<String> ids = Stream.generate(() -> UUID.randomUUID().toString())
    .limit(100)
    .collect(Collectors.toList());
System.out.println(ids.size()); // 100

Ciąg Fibonacciego z użyciem iterate

Liczby Fibonacciego można generować za pomocą stanu przechowującego parę wartości. Dwuargumentowa wersja iterate dostępna w Javie 9 pozwala zrobić to w elegancki sposób.

Stream.iterate(new long[]{0, 1}, p -> new long[]{p[1], p[0]+p[1]})
    .limit(10)
    .map(p -> p[0])
    .forEach(System.out::println); // 0 1 1 2 3 5 8 13 21 34

takeWhile i dropWhile (Java 9+)

takeWhile(predicate) pobiera elementy, dopóki predykat jest spełniony, a następnie zatrzymuje działanie. dropWhile pomija elementy, dopóki predykat nie przestanie być spełniony, a następnie pobiera wszystkie pozostałe.

// takeWhile stops at the first element where predicate is false:
Stream.iterate(1, n -> n + 1)
    .takeWhile(n -> n < 10)
    .forEach(System.out::println); // 1 2 3 4 5 6 7 8 9

Nieskończone strumienie do ponawiania odpytywania

Pętlę odpytywania można zamodelować za pomocą generate: należy generować wyniki sprawdzeń, użyć takeWhile, dopóki warunek nie zostanie spełniony, a następnie pobrać pierwszy pomyślny wynik.

Optional<String> result = Stream.generate(() -> checkJobStatus(jobId))
    .takeWhile(status -> status.equals("PENDING"))
    .findFirst();
// When job completes, takeWhile stops and findFirst gets "DONE"

IntStream.range i rangeClosed

W przypadku skończonych ciągów liczb całkowitych IntStream.range(start, end) i rangeClosed(start, end) są wydajniejsze niż iterate.

// Sum 1 to 1000:
int sum = IntStream.rangeClosed(1, 1000).sum();
System.out.println(sum); // 500500

LongStream.iterate dla ciągów typu long

W przypadku ciągów typu long należy użyć LongStream.iterate, aby uniknąć narzutu automatycznego pakowania występującego w przypadku Stream<Long>.

long sumOfPrimes = LongStream.iterate(2, n -> n + 1)
    .filter(n -> isPrime(n))
    .limit(1000)
    .sum();

Nieskończone strumienie są leniwe

Nieskończone strumienie nie obliczają elementów z wyprzedzeniem. Każdy element jest generowany dopiero wtedy, gdy zażąda go operacja terminalna. Ta leniwa natura sprawia, że nieskończone strumienie są praktyczne.

Szybki test

Jaki mechanizm zatrzymujący jest wymagany podczas pracy z nieskończonym strumieniem?

Powtórzenie

iterate(seed, f) służy do tworzenia sekwencji, a generate(supplier) do niezależnego generowania elementów. Zawsze należy dodać krótką operację terminalną przerywającą przetwarzanie (limit, takeWhile, findFirst). Nieskończone strumienie są leniwe — elementy są materializowane dopiero na żądanie.

Często zadawane pytania

Czy lekcja „Nieskończone strumienie za pomocą iterate i generate” jest bezpłatna?

Tak — pełny tekst „Nieskończone strumienie za pomocą iterate i generate” 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 „Nieskończone strumienie za pomocą iterate i generate”?

Proszę tworzyć nieskończone strumienie za pomocą Stream.iterate i Stream.generate, a następnie zatrzymywać je przez limit lub take-while. Ć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 4 z 4.

Ile czasu zajmuje lekcja „Nieskończone strumienie za pomocą iterate i generate”?

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. flatMap dla zagnieżdżonych kolekcji
  2. Strumienie równoległe: wydajność i pułapki
  3. Spliterator: dzielenie na potrzeby równoległości
  4. Nieskończone strumienie za pomocą iterate i generate
← Powrót do Java Academy