đ Sequence āϏāĻšāĻ āĻাāώাā§ āĻŦোāĻাāϰ āĻāύ্āϝ āĻŽāĻাāϰ āĻāϞ্āĻĒ!
đ Sequence āϏāĻšāĻ āĻাāώাā§ āĻŦোāĻাāϰ āĻāύ্āϝ āĻŽāĻাāϰ āĻāϞ্āĻĒ!
āϤুāĻŽি āĻি āĻāĻāύো āĻāĻāĻা āĻŦā§ āϰাāϏ্āϤাāϰ āĻāĻĒāϰ āĻĨাāĻা āĻĒাāύিāϰ āĻĒাāĻāĻĒেāϰ āĻāĻĨা āĻেāĻŦেāĻো? đ°
đš āĻĒাāĻāĻĒেāϰ āĻŽāϧ্āϝে āĻĒাāύি āĻāĻāϏাāĻĨে āĻāĻŽে āĻĨাāĻে āύা, āĻŦāϰং āĻĒ্āϰāĻŦাāĻšিāϤ āĻšā§ āϧাāĻĒে āϧাāĻĒে
đš āĻĒাāύি āϤāĻāύāĻ āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āϝাā§, āϝāĻāύ āϤুāĻŽি āĻāϞ āĻাāϞু āĻāϰো
đ Kotlin-āĻāϰ Sequence āĻ িāĻ āĻāϰāĻāĻŽāĻ āĻাāĻ āĻāϰে! āĻāĻা āĻāĻāϏাāĻĨে āϏāĻŦ āĻĄেāĻা āĻāĻŽা āϰাāĻে āύা, āĻŦāϰং āĻĒ্āϰā§োāĻāύ āĻšāϞে āϤāĻāύāĻ āĻĄেāĻা āĻĒ্āϰāϏেāϏ āĻāϰে!
đ 1. āϏ্āĻŦাāĻাāĻŦিāĻ āϞিāϏ্āĻ āĻŦāύাāĻŽ Sequence
āϤুāĻŽি āϝāĻĻি āϏাāϧাāϰāĻŖ List āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো, āϤাāĻšāϞে āϏāĻŦ āĻĄেāĻা āĻāĻে āϞোāĻĄ āĻšā§, āϤাāϰāĻĒāϰ āĻাāĻ āĻšā§।
val numbers = listOf(1, 2, 3, 4, 5)
val result = numbers.map { it * 2 }.filter { it > 5 }
println(result) // Output: [6, 8, 10]
đ āĻāĻাāύে āĻĒ্āϰāĻĨāĻŽে āϏāĻŦ āϏংāĻ্āϝা āĻĻ্āĻŦিāĻুāĻŖ āĻšāϞো, āϤাāϰāĻĒāϰ āĻĢিāϞ্āĻাāϰ āĻšāϞো।
āĻিāύ্āϤু āϝāĻĻি Sequence āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো? đ¤
val numbers = sequenceOf(1, 2, 3, 4, 5)
val result = numbers.map { it * 2 }.filter { it > 5 }
println(result.toList()) // Output: [6, 8, 10]
✅ āĻāĻাāύে āϏংāĻ্āϝাāĻুāϞো āϧাāĻĒে āϧাāĻĒে āĻĒ্āϰāϏেāϏ āĻšā§, āĻāĻāϏাāĻĨে āϏāĻŦ āϞোāĻĄ āĻšā§ āύা!
đ 2. āĻিāĻাāĻŦে Sequence āϤৈāϰি āĻāϰা āϝাā§?
āϤুāĻŽি āĻĻুāĻāĻাāĻŦে Sequence āĻŦাāύাāϤে āĻĒাāϰো:
đ 1. sequenceOf() āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰে
val seq = sequenceOf(1, 2, 3, 4, 5)
println(seq.toList()) // Output: [1, 2, 3, 4, 5]
đ āĻāĻা āĻ িāĻ listOf()-āĻāϰ āĻŽāϤো, āĻিāύ্āϤু āĻāϞাāĻĻা āĻাāĻŦে āĻĒ্āϰāϏেāϏ āĻšā§!
đ 2. generateSequence {} āĻĻিā§ে
val seq = generateSequence(1) { it + 2 } // 1 āĻĨেāĻে āĻļুāϰু āĻāϰে ⧍ āĻāϰে āĻŦাā§āĻŦে
println(seq.take(5).toList()) // Output: [1, 3, 5, 7, 9]
✅ āĻāĻাāĻŦে Sequence āĻ
āύāύ্āϤāĻাāϞ āĻāϞāϤে āĻĒাāϰে, āĻিāύ্āϤু āĻāĻŽāϰা take(5) āĻĻিā§ে ā§ĢāĻা āĻāĻāĻেāĻŽ āύিā§েāĻি!
đ 3. Sequence āĻিāĻাāĻŦে āĻাāĻ āĻāϰে? (āϞ্āϝাāĻি āĻĒ্āϰāϏেāϏিং)
Sequence āϤāĻāύāĻ āĻĒ্āϰāϏেāϏ āĻšā§, āϝāĻāύ āϤুāĻŽি āĻāĻে āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো! đ
val numbers = sequenceOf(1, 2, 3, 4, 5)
val result = numbers
.map { println("Mapping: $it"); it * 2 }
.filter { println("Filtering: $it"); it > 5 }
println("Before collecting result...")
println(result.toList()) // Output: āĻĒ্āϰāϏেāϏিং āϤāĻāύāĻ āĻļুāϰু āĻšāĻŦে!
đ āĻāĻাāύে "Before collecting result..." āĻāĻে āĻĒ্āϰিāύ্āĻ āĻšāĻŦে, āĻিāύ্āϤু map āĻāϰ filter āϤāĻāύāĻ āĻাāĻ āĻāϰāĻŦে āϝāĻāύ toList() āĻāϞ āĻāϰāĻŦো!
✅ āĻāĻাāĻে āĻŦāϞে "Lazy Processing"
đ 4. āĻāĻāύ Sequence āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰা āĻāĻিāϤ?
| ❌ List āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো āϝāĻāύ | ✅ Sequence āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰো āϝāĻāύ |
|---|---|
| āĻোāĻ āĻĄেāĻাāϏেāĻ āĻāĻে | āĻŦিāĻļাāϞ āĻĄেāĻাāϏেāĻ āĻāĻে |
| āϏāĻŦ āĻāĻāĻেāĻŽ āĻāĻāϏাāĻĨে āĻĒ্āϰāϏেāϏ āĻāϰāϤে āĻšāĻŦে | āϧাāĻĒে āϧাāĻĒে (āϞ্āϝাāĻি) āĻĒ্āϰāϏেāϏ āĻāϰāϤে āĻšāĻŦে |
| āĻŦাāϰāĻŦাāϰ āĻāĻāĻ āĻĄেāĻা āĻŦ্āϝāĻŦāĻšাāϰ āĻāϰāϤে āĻšāĻŦে | āĻāĻāĻŦাāϰ āĻĒ্āϰāϏেāϏ āĻāϰা āĻšāϞেāĻ āĻšāĻŦে |
| āĻāύ-āĻŽেāĻŽোāϰি āĻĒ্āϰāϏেāϏিং āĻĻāϰāĻাāϰ | āϏ্āĻ্āϰিāĻŽিং āĻĒ্āϰāϏেāϏিং āĻĻāϰāĻাāϰ |
đ¯ āϏংāĻ্āώেāĻĒে āĻŽāύে āϰাāĻাāϰ āĻৌāĻļāϞ!
| đ āĻŦিāώ⧠| đ¤ āĻāĻĻাāĻšāϰāĻŖ |
|---|---|
| Sequence āϤৈāϰি | val seq = sequenceOf(1, 2, 3) |
| Lazy āĻĒ্āϰāϏেāϏিং | map & filter āĻāĻāϏাāĻĨে āĻĒ্āϰāϏেāϏ āĻšā§ āύা, āĻŦāϰং āϝāĻāύ āĻĻāϰāĻাāϰ āϤāĻāύ āĻšā§ |
| āĻ āύāύ্āϤ Sequence | generateSequence(1) { it + 1 } |
| List vs Sequence | āϞিāϏ্āĻ āĻāĻāϏাāĻĨে āĻĒ্āϰāϏেāϏ āĻāϰে, Sequence āϧাāĻĒে āϧাāĻĒে |
đ āĻļেāώ āĻāĻĨা!
āϤাāĻšāϞে? đ Kotlin-āĻāϰ Sequence āĻŽাāύে āĻšāϞো āϧাāĻĒে āϧাāĻĒে āĻĒ্āϰāĻŦাāĻšিāϤ āĻĄেāĻা, āϝেāύ āĻĒাāύিāϰ āĻĒাāĻāĻĒ āĻĨেāĻে āĻĒাāύি āĻāϏে! đ°✨
āĻāĻāύ āĻি āĻŽāĻা āϞাāĻāϞো? đđĨ
Comments
Post a Comment