Java Academy · บทเรียน

สตรีมไม่สิ้นสุดด้วย iterate และ generate

สร้างสตรีมไม่สิ้นสุดด้วย Stream.iterate และ Stream.generate จากนั้นใช้ limit หรือ take-while เพื่อหยุด

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

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

สตรีมแบบไม่สิ้นสุดคืออะไร

สตรีมของ Java สามารถทำงานแบบไม่สิ้นสุดได้ โดยจะสร้างองค์ประกอบตามต้องการโดยไม่มีจุดสิ้นสุด ต้องจบการทำงานด้วยการดำเนินการจำกัดขอบเขต (limit, takeWhile, findFirst เป็นต้น) เพื่อป้องกันการทำงานตลอดไป

Stream.iterate: ลำดับที่มีค่าเริ่มต้น

Stream.iterate(seed, f) จะสร้างสตรีมแบบไม่สิ้นสุดโดยใช้ f กับค่าก่อนหน้าซ้ำ ๆ องค์ประกอบแรกคือค่าเริ่มต้น

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

iterate พร้อมเพรดิเคต (Java 9+)

Stream.iterate(seed, predicate, f) เพิ่มเงื่อนไขหยุด คล้ายลูป for ที่มีเงื่อนไข สตรีมจะหยุดเมื่อเพรดิเคตเป็นเท็จ

// 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: ตัวสร้างแบบไร้สถานะ

Stream.generate(Supplier) จะเรียกตัวสร้างสำหรับแต่ละองค์ประกอบ ตัวสร้างอาจไร้สถานะ (เช่น ตัวเลขสุ่ม) หรือมีสถานะ (เช่น ใช้ตัวนับภายนอก)

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

การสร้าง UUID

ใช้ generate ร่วมกับ UUID::randomUUID เพื่อสร้างสตรีมของตัวระบุที่ไม่ซ้ำกันสำหรับการสร้าง ID ของชุดงาน

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

ฟีโบนักชีด้วย iterate

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

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 และ dropWhile (Java 9+)

takeWhile(predicate) จะรับองค์ประกอบตราบใดที่เพรดิเคตเป็นจริง แล้วหยุดทำงาน ส่วน dropWhile จะข้ามองค์ประกอบไปจนกว่าเพรดิเคตจะเป็นเท็จ จากนั้นจึงรับองค์ประกอบที่เหลือ

// 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

สตรีมแบบไม่สิ้นสุดสำหรับการตรวจสอบสถานะซ้ำ

จำลองลูปตรวจสอบซ้ำด้วย generate โดยสร้างผลลัพธ์การตรวจสอบ ใช้ takeWhile ตราบใดที่ยังไม่ตรงตามเงื่อนไข แล้วรับผลสำเร็จรายการแรก

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

IntStream.range และ rangeClosed

สำหรับลำดับจำนวนเต็มแบบมีขอบเขต IntStream.range(start, end) และ rangeClosed(start, end) มีประสิทธิภาพมากกว่า iterate

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

LongStream.iterate สำหรับลำดับ long

ใช้ LongStream.iterate สำหรับลำดับ long เพื่อหลีกเลี่ยงค่าใช้จ่ายจากการห่อชนิดอัตโนมัติของ Stream<Long>

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

สตรีมแบบไม่สิ้นสุดทำงานแบบประเมินเมื่อจำเป็น

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

เมื่อทำงานกับสตรีมแบบไม่สิ้นสุด ต้องใช้กลไกการหยุดแบบใด

ตอบคำถามในบทเรียนแบบโต้ตอบ

ทบทวน

iterate(seed, f) ใช้สำหรับสร้างลำดับ และ generate(supplier) ใช้สำหรับสร้างองค์ประกอบที่เป็นอิสระต่อกัน ควรเพิ่มการดำเนินการปลายทางแบบหยุดก่อนเสมอ (limit, takeWhile, findFirst) สตรีมแบบไม่สิ้นสุดจะประเมินเมื่อจำเป็น — สร้างเป็นรูปธรรมเมื่อมีการร้องขอเท่านั้น

เริ่มต้นได้ฟรี

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

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

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

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “สตรีมไม่สิ้นสุดด้วย iterate และ generate” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “สตรีมไม่สิ้นสุดด้วย iterate และ generate”

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

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

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

บทเรียน “สตรีมไม่สิ้นสุดด้วย iterate และ generate” ใช้เวลานานแค่ไหน

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

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

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

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

flatMap สำหรับคอลเลกชันแบบซ้อน
สตรีมแบบขนาน: ประสิทธิภาพและข้อควรระวัง
Spliterator: การแบ่งเพื่อการทำงานแบบขนาน
สตรีมไม่สิ้นสุดด้วย iterate และ generate

← กลับไปที่ Java Academy