Java Academy · Pelajaran

Membuat Stream Primitif

iterate dan generate.

Membuat Stream Primitif adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Stream Tak Terbatas Memerlukan Batas

iterate dan generate membuat stream yang berpotensi tak terbatas. Anda harus menambahkan limit (atau sebuah predicate) agar stream tersebut menjadi terbatas.

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

iterate dengan Nilai Awal

iterate(seed, next) dimulai dari nilai awal dan berulang kali menerapkan fungsi tersebut pada nilai sebelumnya.

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

iterate dengan Predikat

iterate(seed, hasNext, next) dengan tiga argumen berhenti secara otomatis ketika predikat bernilai salah, seperti perulangan fungsional.

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

generate dengan Pemasok

generate menerima IntSupplier yang menghasilkan setiap elemen secara independen, tanpa bergantung pada nilai sebelumnya.

import java.util.stream.IntStream;

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

Menghasilkan Bilangan Acak

Pemasok untuk generate dapat memanggil sumber acak. Di sini, setiap elemen merupakan hasil lemparan dadu yang independen.

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 dibandingkan dengan generate

Perbedaan utama:

iterate: setiap nilai diturunkan dari nilai sebelumnya (urutan).
generate: setiap nilai dihasilkan secara independen (konstanta, bilangan acak).

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

Mengagregasi Aliran yang Dihasilkan

Setelah dibatasi, aliran yang dihasilkan mendukung semua agregasi biasa.

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

Fibonacci dengan iterate pada Aliran Objek

Untuk urutan yang memiliki status seperti Fibonacci, gunakan Stream.iterate pada pasangan larik, lalu petakan kembali ke 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);
    }
}

Membangun Larik dari Pembangkit

Gabungkan pembangkit dengan toArray untuk membangun larik primitif secara prosedural.

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

Evaluasi Malas Menghemat Pekerjaan

Aliran bersifat malas: dengan limit, hanya elemen yang diperlukan yang dihasilkan, bahkan dari sumber tak terbatas.

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

Utamakan Bentuk Predikat

iterate berbasis predikat sering kali lebih jelas daripada iterate(...).limit(...) karena kondisi penghentian berada bersama logika pembangkitan.

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

Pemeriksaan Singkat

Apa yang terjadi jika Anda memanggil generate tanpa limit, lalu memanggil operasi terminal seperti forEach?

Rangkuman

Anda telah menghasilkan aliran primitif:

iterate menurunkan setiap nilai dari nilai sebelumnya.
generate menghasilkan nilai secara independen dari pemasok.
Keduanya tidak terbatas; batasi dengan limit atau bentuk predikat dari iterate.
Kemalasan berarti hanya elemen yang diperlukan yang dihitung.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membuat Stream Primitif” gratis?

Ya — teks lengkap “Membuat Stream Primitif” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membuat Stream Primitif”?

iterate dan generate. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Membuat Stream Primitif” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy