0Pricing
Java Academy · Lekcja

Generowanie strumieni typów prostych

iterate i generate

Generowanie strumieni typów prostych 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.

Strumienie nieskończone wymagają ograniczenia

iterate i generate tworzą potencjalnie nieskończone strumienie. Należy dodać limit albo predykat, aby uczynić je skończonymi.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(1, n -> n + 1)
            .limit(5)
            .forEach(System.out::println);
    }
}

Iterowanie z wartością początkową

iterate(seed, next) rozpoczyna od wartości początkowej i wielokrotnie stosuje funkcję do poprzedniej wartości.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(2, n -> n * 2)
            .limit(5)
            .forEach(System.out::println);
    }
}

Iterowanie z predykatem

Trzyargumentowa wersja iterate(seed, hasNext, next) zatrzymuje się automatycznie, gdy predykat zwróci wartość fałszywą, podobnie jak funkcyjna pętla for.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(1, n -> n <= 100, n -> n * 3)
            .forEach(System.out::println);
    }
}

Generowanie za pomocą dostawcy

generate przyjmuje obiekt IntSupplier, który niezależnie generuje każdy element bez zależności od poprzedniej wartości.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.generate(() -> 7)
            .limit(3)
            .forEach(System.out::println);
    }
}

Generowanie liczb losowych

Dostawca przekazany do generate może wywoływać źródło losowości. W tym przypadku każdy element jest niezależnym rzutem kostką.

import java.util.Random;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        Random rnd = new Random(42);
        IntStream.generate(() -> rnd.nextInt(6) + 1)
            .limit(5)
            .forEach(System.out::println);
    }
}

iterate a generate

Najważniejsza różnica:

  • iterate: każda wartość jest wyprowadzana z poprzedniej (sekwencje).
  • generate: każda wartość jest generowana niezależnie (stałe, wartości losowe).
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.iterate(1, n -> n + 1).limit(10).sum();
        System.out.println(sum);
    }
}

Agregowanie wygenerowanych strumieni

Po ograniczeniu długości wygenerowane strumienie obsługują wszystkie standardowe operacje agregujące.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.iterate(0, n -> n + 2)
            .limit(50)
            .filter(n -> n % 3 == 0)
            .count();
        System.out.println(count);
    }
}

Liczby Fibonacciego z iterate na strumieniu obiektów

W przypadku sekwencji ze stanem, takich jak ciąg Fibonacciego, należy użyć Stream.iterate na parze elementów tablicy, a następnie ponownie zmapować wynik na typ int.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.iterate(new int[]{0, 1}, p -> new int[]{p[1], p[0] + p[1]})
            .limit(8)
            .mapToInt(p -> p[0])
            .forEach(System.out::println);
    }
}

Budowanie tablicy za pomocą generatora

Połączenie generatora z toArray pozwala programowo utworzyć tablicę typów prostych.

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

public class Main {
    public static void main(String[] args) {
        int[] squares = IntStream.iterate(1, n -> n + 1)
            .limit(5)
            .map(n -> n * n)
            .toArray();
        System.out.println(Arrays.toString(squares));
    }
}

Leniwość oszczędza pracę

Strumienie są leniwe: wraz z użyciem limit generowane są tylko potrzebne elementy, nawet gdy źródło jest nieskończone.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int first = IntStream.iterate(10, n -> n + 10)
            .filter(n -> n > 25)
            .findFirst()
            .getAsInt();
        System.out.println(first);
    }
}

Preferowanie wersji z predykatem

Wersja iterate oparta na predykacie jest często czytelniejsza niż iterate(...).limit(...), ponieważ warunek zakończenia znajduje się razem z logiką generowania.

import java.util.stream.LongStream;

public class Main {
    public static void main(String[] args) {
        long product = LongStream.iterate(1, n -> n <= 5, n -> n + 1)
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

Szybkie sprawdzenie

Co się stanie po wywołaniu generate bez limit, a następnie operacji kończącej, takiej jak forEach?

Podsumowanie

Utworzono strumienie prymitywne:

  • iterate wyprowadza każdą wartość z poprzedniej.
  • generate niezależnie generuje wartości za pomocą dostawcy.
  • Oba strumienie są nieskończone; należy ograniczyć je za pomocą limit lub wersji iterate z predykatem.
  • Leniwość oznacza, że obliczane są tylko potrzebne elementy.

Często zadawane pytania

Czy lekcja „Generowanie strumieni typów prostych” jest bezpłatna?

Tak — pełny tekst „Generowanie strumieni typów prostych” 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 „Generowanie strumieni typów prostych”?

iterate i generate Ć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 „Generowanie strumieni typów prostych”?

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