Java Academy · บทเรียน

การสร้างสตรีมชนิดพื้นฐาน

iterate และ generate

บทเรียน 4 จาก 413 ขั้นตอน

การสร้างสตรีมชนิดพื้นฐาน เป็นบทเรียน Java Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Java Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

สตรีมไม่สิ้นสุดต้องมีขอบเขต

iterate และ generate สร้างสตรีมที่อาจไม่สิ้นสุดได้ คุณต้องเพิ่ม limit (หรือเพรดิเคต) เพื่อทำให้สตรีมมีจำนวนจำกัด

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(seed, next) เริ่มต้นจากค่าเริ่มต้น แล้วเรียกใช้ฟังก์ชันกับค่าก่อนหน้าซ้ำไปเรื่อย ๆ

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(seed, hasNext, next) แบบสามอาร์กิวเมนต์จะหยุดโดยอัตโนมัติเมื่อเงื่อนไขเป็นเท็จ คล้ายกับลูปวนซ้ำเชิงฟังก์ชัน

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 รับ IntSupplier ซึ่งสร้างแต่ละองค์ประกอบอย่างเป็นอิสระ โดยไม่ขึ้นอยู่กับค่าก่อนหน้า

import java.util.stream.IntStream;

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

การสร้างตัวเลขสุ่ม

ตัวจัดหาค่าของ generate สามารถเรียกใช้แหล่งข้อมูลสุ่มได้ ในที่นี้แต่ละองค์ประกอบคือผลการทอยลูกเต๋าที่เป็นอิสระต่อกัน

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 เทียบกับ generate

ความแตกต่างสำคัญ:

  • iterate: แต่ละค่าถูกสร้างจากค่าก่อนหน้า (เป็นลำดับ)
  • generate: แต่ละค่าถูกสร้างขึ้นอย่างเป็นอิสระ (เช่น ค่าคงที่หรือค่าสุ่ม)
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);
    }
}

การรวมผลลัพธ์จากสตรีมที่สร้างขึ้น

เมื่อจำกัดจำนวนแล้ว สตรีมที่สร้างขึ้นจะรองรับการรวมผลลัพธ์ทั่วไปทั้งหมด

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

ฟีโบนัชชีด้วย iterate บนสตรีมอ็อบเจ็กต์

สำหรับลำดับที่มีสถานะ เช่น ลำดับฟีโบนัชชี ให้ใช้ Stream.iterate กับคู่ในอาร์เรย์ แล้วแปลงกลับเป็นจำนวนเต็ม

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

การสร้างอาร์เรย์จากตัวสร้างค่า

ใช้ตัวสร้างค่าร่วมกับ toArray เพื่อสร้างอาร์เรย์ชนิดพื้นฐานตามขั้นตอนได้

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

การประเมินแบบขี้เกียจช่วยลดงาน

สตรีมจะประเมินผลแบบขี้เกียจ ดังนั้นเมื่อใช้ limit ระบบจะสร้างเฉพาะองค์ประกอบที่จำเป็น แม้แหล่งข้อมูลจะไม่มีที่สิ้นสุด

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

เลือกใช้รูปแบบเงื่อนไข

iterate ที่ใช้เงื่อนไขมักเข้าใจได้ชัดเจนกว่า iterate(...).limit(...) เพราะเงื่อนไขหยุดอยู่ร่วมกับตรรกะการสร้างค่า

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

ตรวจสอบความเข้าใจ

จะเกิดอะไรขึ้นหากเรียกใช้ generate โดยไม่มี limit แล้วตามด้วยการดำเนินการปลายทาง เช่น forEach?

สรุปทบทวน

คุณได้สร้างสตรีมชนิดพื้นฐาน:

  • iterate สร้างแต่ละค่าจากค่าก่อนหน้า
  • generate สร้างค่าอย่างเป็นอิสระจากตัวจัดหาค่า
  • ทั้งคู่ไม่มีที่สิ้นสุด ให้จำกัดจำนวนด้วย limit หรือรูปแบบเงื่อนไขของ iterate
  • การประเมินแบบขี้เกียจหมายความว่าจะคำนวณเฉพาะองค์ประกอบที่จำเป็น
เริ่มต้นได้ฟรี

เรียนรู้ Java ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
104
บทเรียน
374

คำถามที่พบบ่อย

บทเรียน “การสร้างสตรีมชนิดพื้นฐาน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การสร้างสตรีมชนิดพื้นฐาน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Java Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การสร้างสตรีมชนิดพื้นฐาน”

iterate และ generate คุณปฏิบัติ Java Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Java Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Java Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การสร้างสตรีมชนิดพื้นฐาน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Java Academy นี้ได้ไหม

ได้ บทเรียน Java Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. IntStream และ LongStream
  2. การดำเนินการช่วงและการรวมค่า
  3. การแมปไปยังและจากสตรีมออบเจ็กต์
  4. การสร้างสตรีมชนิดพื้นฐาน
← กลับไปที่ Java Academy