Kotlin Academy · บทเรียน

เหตุใดจึงใช้ซีเควนซ์

การประเมินค่าแบบขี้เกียจ

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

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

ลำดับคืออะไร

Sequence คล้ายกับคอลเลกชัน แต่ประมวลผลองค์ประกอบแบบประเมินผลเมื่อจำเป็น การดำเนินการจะยังไม่ทำงานจนกว่าการดำเนินการปลายทางจะร้องขอผลลัพธ์ และองค์ประกอบจะไหลผ่านห่วงโซ่ทั้งหมดทีละรายการ

คอลเลกชันที่ประมวลผลทันที

การดำเนินการกับคอลเลกชันมาตรฐานเป็นแบบประมวลผลทันที โดยแต่ละขั้นตอน (filter, map) จะประมวลผลรายการทั้งหมดและสร้างรายการระหว่างกลางรายการใหม่ให้เสร็จก่อนเริ่มขั้นตอนถัดไป

fun main() {
    val result = listOf(1, 2, 3, 4)
        .map { it * 2 }
        .filter { it > 4 }
    println(result)
}

ต้นทุนของรายการระหว่างกลาง

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

ลำดับแบบประเมินผลเมื่อจำเป็น

ลำดับจะประมวลผลองค์ประกอบแต่ละรายการผ่านลำดับการประมวลผลทั้งหมดก่อนจะไปยังรายการถัดไป โดยไม่สร้างรายการระหว่างกลาง คุณสามารถแปลงคอลเลกชันได้ด้วย asSequence()

fun main() {
    val result = listOf(1, 2, 3, 4)
        .asSequence()
        .map { it * 2 }
        .filter { it > 4 }
        .toList()
    println(result)
}

การดูคำสั่งการทำงาน

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

fun main() {
    listOf(1, 2, 3).asSequence()
        .map { println("map $it"); it * 2 }
        .filter { println("filter $it"); it > 2 }
        .toList()
}

ลำดับการประมวลผลแบบทันที

ลองเปรียบเทียบกับรายการปกติ: map จะทำงานกับองค์ประกอบ ALL ก่อน จากนั้น filter จึงทำงานกับองค์ประกอบทั้งหมด

fun main() {
    listOf(1, 2, 3)
        .map { println("map $it"); it * 2 }
        .filter { println("filter $it"); it > 2 }
}

การหยุดลัด

การประเมินผลเมื่อจำเป็นทำให้เกิดการหยุดลัดได้ การดำเนินการอย่าง first หรือ find จะหยุดทันทีที่พบผลลัพธ์ และไม่ต้องทำงานกับส่วนที่เหลือ

fun main() {
    val firstBig = (1..1000000).asSequence()
        .map { it * 2 }
        .first { it > 10 }
    println(firstBig)
}

การดำเนินการระหว่างกลางและปลายทาง

การดำเนินการกับลำดับแบ่งออกเป็นสองประเภท

ระหว่างกลาง (map, filter, take): ประเมินผลเมื่อจำเป็น และส่งคืนลำดับอีกชุดหนึ่ง
ปลายทาง (toList, sum, first): เริ่มการคำนวณและสร้างค่าออกมา

ไม่มีการทำงานหากไม่มีการดำเนินการปลายทาง

ห่วงโซ่การดำเนินการระหว่างกลางเพียงอย่างเดียวจะไม่เรียกใช้โค้ดใด ๆ จนกว่าจะเรียกใช้การดำเนินการปลายทาง แลมบ์ดาจึงจะเริ่มทำงาน

fun main() {
    val seq = listOf(1, 2, 3).asSequence()
        .map { println("processing $it"); it }
    println("Nothing printed yet")
    seq.toList()
}

ลำดับมีประโยชน์เมื่อใด

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

ภาพในใจ

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

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

เหตุใดลำดับจึงอาจมีประสิทธิภาพมากกว่าคอลเลกชัน

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

สรุปทบทวน

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

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

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

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

คอร์ส: 51
บทเรียน: 203

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

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

บทเรียน “เหตุใดจึงใช้ซีเควนซ์” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “เหตุใดจึงใช้ซีเควนซ์”

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

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

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

บทเรียน “เหตุใดจึงใช้ซีเควนซ์” ใช้เวลานานแค่ไหน

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

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

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

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

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