0Pricing
Scala for Backend Engineering & Functional Programming · บทเรียน

เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป

สำรวจคอลเลกชันแบบไม่เปลี่ยนรูปพื้นฐาน เช่น 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. เจาะลึกคอลเลกชันแบบไม่เปลี่ยนรูป
  2. การดำเนินการเชิงฟังก์ชันกับคอลเลกชัน
  3. Option, Try, Either สำหรับข้อผิดพลาด
← กลับไปที่ Scala for Backend Engineering & Functional Programming