เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป
สำรวจคอลเลกชันแบบไม่เปลี่ยนรูปพื้นฐาน เช่น List, Map และ Set พร้อมเรียนรู้การใช้งานอย่างมีประสิทธิภาพ
เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน
ภาพรวมคอลเลกชันที่ไม่เปลี่ยนแปลง
ยินดีต้อนรับสู่บทเรียนเรื่องคอลเลกชันที่ไม่เปลี่ยนแปลงครับ/ค่ะ! ใน Scala คอลเลกชันเหล่านี้เป็นพื้นฐานสำคัญของการเขียนโค้ดที่แข็งแกร่ง ทำงานพร้อมกันได้ และคาดเดาได้ โดยเฉพาะในการเขียนโปรแกรมเชิงฟังก์ชัน
เราจะสำรวจชนิดข้อมูลพื้นฐาน เช่น List, Map และ Set โดยเน้นการใช้งานอย่างมีประสิทธิภาพและปลอดภัย
เหตุใดความไม่เปลี่ยนแปลงจึงสำคัญ
ความไม่เปลี่ยนแปลงหมายความว่า เมื่อสร้างคอลเลกชันขึ้นมาแล้ว คอลเลกชันนั้นจะไม่สามารถเปลี่ยนแปลงได้ การดำเนินการใด ๆ ที่ดูเหมือนเป็นการ 'แก้ไข' จะส่งคืนคอลเลกชันใหม่แทน
- คาดเดาได้: ทำความเข้าใจเหตุผลของโค้ดได้ง่ายขึ้น
- ปลอดภัยต่อเธรด: ไม่จำเป็นต้องใช้กลไกล็อก เนื่องจากข้อมูลไม่เคยเปลี่ยนแปลง
- ไม่มีผลข้างเคียง: การดำเนินการจะไม่เปลี่ยนแปลงข้อมูลที่อื่นโดยไม่คาดคิด
ลิสต์ใน Scala: ลำดับที่เรียงตามลำดับ
List ใน Scala คือลำดับที่ไม่เปลี่ยนแปลงและเรียงลำดับไว้ของสมาชิกชนิดเดียวกัน เหมาะสำหรับข้อมูลตามลำดับที่ลำดับมีความสำคัญ
คุณสามารถสร้างลิสต์ได้ง่าย ๆ ด้วยการระบุสมาชิกทีละรายการ
object Main {
def main(args: Array[String]): Unit = {
val numbers = List(1, 2, 3, 4, 5)
val fruits = List("apple", "banana", "cherry")
println(s"Numbers list: $numbers")
println(s"Fruits list: $fruits")
}
}การดำเนินการกับลิสต์: หัว ท้าย และ Cons
ลิสต์มีการดำเนินการทั่วไป เช่น การเรียกดู head (สมาชิกตัวแรก) และ tail (ส่วนที่เหลือของลิสต์) ตัวดำเนินการ :: (cons) ใช้เพิ่มสมาชิกไว้ด้านหน้าเพื่อสร้างลิสต์ใหม่
object Main {
def main(args: Array[String]): Unit = {
val numbers = List(10, 20, 30)
println(s"Original list: $numbers")
println(s"Head of list: ${numbers.head}") // 10
println(s"Tail of list: ${numbers.tail}") // List(20, 30)
val newList = 5 :: numbers // Prepend 5
println(s"List with 5 prepended: $newList")
}
}แมปใน Scala: ความสัมพันธ์ระหว่างคีย์กับค่า
Map คือคอลเลกชันที่ไม่เปลี่ยนแปลงซึ่งจัดเก็บคู่คีย์กับค่า คีย์แต่ละรายการไม่ซ้ำกันและเชื่อมโยงกับค่าเดียว แมปเหมาะอย่างยิ่งสำหรับการค้นค่าด้วยคีย์ที่ระบุ
object Main {
def main(args: Array[String]): Unit = {
val ages = Map("Alice" -> 30, "Bob" -> 25, "Charlie" -> 35)
val codes = Map(1 -> "One", 2 -> "Two")
println(s"Ages map: $ages")
println(s"Codes map: $codes")
}
}การดำเนินการกับแมป: การเข้าถึงและการอัปเดต
คุณสามารถเข้าถึงค่าใน Map ได้โดยใช้คีย์ หากต้องการ 'อัปเดต' หรือ 'เพิ่ม' คู่คีย์กับค่า ให้สร้างแมปใหม่ที่มีการเปลี่ยนแปลง โดยแมปเดิมยังคงไม่ถูกแตะต้อง
object Main {
def main(args: Array[String]): Unit = {
val ages = Map("Alice" -> 30, "Bob" -> 25)
println(s"Original ages: $ages")
println(s"Bob's age: ${ages("Bob")}")
val updatedAges = ages + ("Charlie" -> 35) // Add new pair
println(s"Ages after adding Charlie: $updatedAges")
val changedAges = updatedAges + ("Alice" -> 31) // Update Alice's age
println(s"Ages after updating Alice: $changedAges")
}
}เซตใน Scala: สมาชิกที่ไม่ซ้ำกัน
Set คือคอลเลกชันที่ไม่เปลี่ยนแปลงของสมาชิกที่ไม่ซ้ำกัน ต่างจากลิสต์ ลำดับของสมาชิกในเซตไม่รับประกัน และสมาชิกที่ซ้ำกันจะถูกละเว้นโดยอัตโนมัติ
เซตเหมาะอย่างยิ่งสำหรับตรวจสอบการมีสมาชิกอยู่ หรือรับประกันความไม่ซ้ำกัน
object Main {
def main(args: Array[String]): Unit = {
val numbers = Set(1, 2, 2, 3, 4, 3, 5)
val letters = Set('a', 'b', 'a')
println(s"Unique numbers: $numbers")
println(s"Unique letters: $letters")
}
}การดำเนินการกับเซต: เพิ่ม ลบ และยูเนียน
เช่นเดียวกับลิสต์และแมป การดำเนินการกับเซต เช่น การเพิ่มหรือลบสมาชิก จะส่งคืนSet ใหม่เช่นกัน คุณยังสามารถดำเนินการตามทฤษฎีเซต เช่น union (การรวมเซต) ได้อีกด้วย
object Main {
def main(args: Array[String]): Unit = {
val setA = Set(1, 2, 3)
val setB = Set(3, 4, 5)
println(s"Set A: $setA")
println(s"Set B: $setB")
val addedSet = setA + 4 // Add element
println(s"Set A + 4: $addedSet")
val removedSet = setA - 2 // Remove element
println(s"Set A - 2: $removedSet")
val unionSet = setA union setB // Combine sets
println(s"Set A union Set B: $unionSet")
}
}ความไม่เปลี่ยนแปลง: ของเดิมยังคงอยู่
สิ่งสำคัญที่ต้องจำไว้คือ การดำเนินการ 'แก้ไข' ทั้งหมดกับคอลเลกชันที่ไม่เปลี่ยนแปลงของ Scala จะส่งคืนคอลเลกชันใหม่ คอลเลกชันเดิมจะไม่ถูกเปลี่ยนแปลง
พฤติกรรมนี้เป็นรากฐานสำคัญของการเขียนโปรแกรมเชิงฟังก์ชันใน Scala
object Main {
def main(args: Array[String]): Unit = {
val originalList = List(10, 20, 30)
println(s"Original List: $originalList")
val doubledList = originalList.map(_ * 2) // map returns a NEW list
println(s"List after map: $doubledList")
println(s"Original list is still: $originalList") // Unchanged!
}
}ตรวจสอบความเข้าใจ
พิจารณาชุดโค้ด Scala ต่อไปนี้:
val mySet = Set(1, 2, 3)
val newSet = mySet + 3 + 4
val finalSet = newSet - 2หลังจากดำเนินการเหล่านี้ ค่า mySet จะเป็นเท่าใด
ทบทวน: คอลเลกชันที่ไม่เปลี่ยนแปลง
คุณได้ศึกษาเชิงลึกเกี่ยวกับคอลเลกชันพื้นฐานที่ไม่เปลี่ยนแปลงของ Scala:
- ลิสต์: ลำดับที่เรียงตามลำดับ เหมาะสำหรับข้อมูลตามลำดับ
- แมป: คู่คีย์กับค่า มีประสิทธิภาพสำหรับการค้นหา
- เซต: สมาชิกที่ไม่ซ้ำกัน เหมาะสำหรับตรวจสอบการมีสมาชิกอยู่
สิ่งสำคัญที่ควรจำคือความไม่เปลี่ยนแปลง การดำเนินการจะส่งคืนคอลเลกชันใหม่เสมอ จึงช่วยให้คาดเดาได้และปลอดภัย
คำถามที่พบบ่อย
บทเรียน “เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป”
สำรวจคอลเลกชันแบบไม่เปลี่ยนรูปพื้นฐาน เช่น List, Map และ Set พร้อมเรียนรู้การใช้งานอย่างมีประสิทธิภาพ คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน
บทเรียน “เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม
ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป
- การดำเนินการเชิงฟังก์ชันกับคอลเลกชัน
- Option, Try, Either สำหรับข้อผิดพลาด