Scala for Backend Engineering & Functional Programming · Pelajaran

Mendalami Koleksi Imutabel

Jelajahi koleksi imutabel dasar seperti List, Map, dan Set, serta pelajari penggunaannya secara efisien.

Mendalami Koleksi Imutabel adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Koleksi yang Tidak Dapat Diubah: Gambaran Umum

Selamat datang di koleksi yang tidak dapat diubah! Di Scala, koleksi ini merupakan dasar untuk menulis kode yang tangguh, konkuren, dan mudah diprediksi, terutama dalam pemrograman fungsional.

Kita akan mempelajari jenis dasar seperti List, Map, dan Set, dengan fokus pada penggunaannya yang efisien dan aman.

Mengapa Ketidakdapatubahan Penting

Ketidakdapatubahan berarti setelah sebuah koleksi dibuat, koleksi tersebut tidak dapat diubah. Operasi apa pun yang tampak seperti 'mengubahnya' sebenarnya mengembalikan koleksi baru.

Kemudahan Diprediksi: Kode lebih mudah dipahami.
Keamanan Utas: Tidak diperlukan kunci karena data tidak pernah berubah.
Tanpa Efek Samping: Operasi tidak akan mengubah data di tempat lain secara tak terduga.

List Scala: Urutan Teratur

List di Scala adalah urutan elemen yang tidak dapat diubah dan teratur dengan jenis yang sama. List ideal untuk data berurutan yang urutannya penting.

Anda dapat membuat list dengan cukup mencantumkan elemen-elemennya.

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")
  }
}

Operasi List: Head, Tail, Cons

List menyediakan operasi umum seperti mengambil head (elemen pertama) dan tail (sisa list). Operator :: (cons) digunakan untuk menambahkan elemen di awal sehingga membuat list baru.

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")
  }
}

Map Scala: Asosiasi Kunci-Nilai

Map adalah koleksi yang tidak dapat diubah dan menyimpan pasangan kunci-nilai. Setiap kunci bersifat unik dan dipetakan ke satu nilai. Map sangat baik untuk mencari nilai berdasarkan kunci tertentu.

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")
  }
}

Operasi Map: Mengakses & Memperbarui

Anda dapat mengakses nilai dalam Map menggunakan kuncinya. Untuk 'memperbarui' atau 'menambahkan' pasangan kunci-nilai, Anda membuat map baru yang berisi perubahan tersebut, sementara map asli tetap tidak berubah.

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")
  }
}

Set Scala: Elemen Unik

Set adalah koleksi yang tidak dapat diubah dan berisi elemen-elemen unik. Tidak seperti List, urutan elemen dalam Set tidak dijamin, dan elemen duplikat secara otomatis diabaikan.

Set sangat cocok untuk memeriksa keanggotaan atau memastikan keunikan.

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")
  }
}

Operasi Set: Menambah, Menghapus, Menggabungkan

Seperti pada List dan Map, operasi pada Set, seperti menambah atau menghapus elemen, juga mengembalikan Set baru. Anda juga dapat melakukan operasi teori himpunan seperti union (menggabungkan himpunan).

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")
  }
}

Ketidakdapatubahan: Yang Asli Tetap Ada

Penting untuk diingat bahwa semua operasi 'pengubahan' pada koleksi Scala yang tidak dapat diubah akan mengembalikan koleksi baru. Koleksi asli tidak pernah berubah.

Perilaku ini merupakan dasar penting pemrograman fungsional di 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!
  }
}

Periksa Pemahaman Anda

Perhatikan potongan kode Scala berikut:

val mySet = Set(1, 2, 3)
val newSet = mySet + 3 + 4
val finalSet = newSet - 2

Berapakah nilai mySet setelah operasi-operasi ini?

Ringkasan: Koleksi yang Tidak Dapat Diubah

Anda telah mempelajari secara mendalam koleksi dasar Scala yang tidak dapat diubah:

List: Urutan teratur, baik untuk data berurutan.
Map: Pasangan kunci-nilai, efisien untuk pencarian.
Set: Elemen unik, sangat baik untuk pemeriksaan keanggotaan.

Inti pentingnya adalah ketidakdapatubahan: operasi selalu mengembalikan koleksi baru sehingga memastikan kemudahan diprediksi dan keamanan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mendalami Koleksi Imutabel” gratis?

Ya — teks lengkap “Mendalami Koleksi Imutabel” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Mendalami Koleksi Imutabel”?

Jelajahi koleksi imutabel dasar seperti List, Map, dan Set, serta pelajari penggunaannya secara efisien. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 3.

Berapa lama pelajaran “Mendalami Koleksi Imutabel” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming