Bagian ini mulai masuk ke konsep yang sangat penting dalam Kotlin, yaitu memodifikasi MutableList.

Kalau sebelumnya kita belajar bagaimana membaca/mengambil data dari List, sekarang kita belajar bagaimana mengubah isi List.

1. Apa maksud “modifying a list”?

Modifying berarti mengubah isi sebuah List.

Pada MutableList, kita bisa melakukan beberapa perubahan, misalnya:

• ➕ menambahkan elemen
• ➖ menghapus elemen
• ✏️ mengubah nilai yang sudah ada
• 🔀 mengubah urutan elemen

Contohnya kita punya:

val names = mutableListOf(
    "Ali",
    "Jack",
    "George"
)

Awalnya:

[Ali, Jack, George]

Kita bisa mengubahnya menjadi:

[Ali, Jack, George, Sarah]

atau:

[Ali, George]

atau:

[Ali, Sarah, George]

dan sebagainya.

2. Kenapa harus MutableList?

Ini penting.

Sebelumnya kita belajar:

val names = listOf("Ali", "Jack", "George")

List biasa digunakan sebagai collection yang tidak menyediakan operasi modifikasi melalui tipe List.

Jadi kita tidak bisa melakukan:

names.add("Sarah")

Sedangkan:

val names = mutableListOf("Ali", "Jack", "George")

menghasilkan MutableList, sehingga kita bisa memodifikasinya:

names.add("Sarah")

Hasil:

[Ali, Jack, George, Sarah]

Jadi untuk materi ini, fokus kita adalah:

MutableList

3. Modifikasi pertama: menambahkan elemen

Caption menggunakan istilah:

Appending elements

Appending berarti menambahkan elemen di bagian akhir collection.

Misalnya kita punya:

val names = mutableListOf(
    "Ali",
    "Jack",
    "George"
)

Visualisasinya:

┌─────┬──────┬────────┐
│ Ali │ Jack │ George │
└─────┴──────┴────────┘
   0      1       2

Kemudian kita ingin menambahkan:

Sarah

ke bagian akhir.

Hasilnya:

┌─────┬──────┬────────┬───────┐
│ Ali │ Jack │ George │ Sarah │
└─────┴──────┴────────┴───────┘
   0      1       2       3

Inilah yang disebut appending.

4. Menggunakan add()

Untuk menambahkan elemen ke MutableList, kita bisa menggunakan:

add()

Contoh:

val names = mutableListOf(
    "Ali",
    "Jack",
    "George"
)

names.add("Sarah")

Sekarang isi names menjadi:

[Ali, Jack, George, Sarah]

5. add() tanpa index = tambahkan ke akhir

Ini pola yang sangat penting:

names.add("Sarah")

Kita hanya memberikan satu argument, yaitu elemen yang ingin ditambahkan.

Kotlin akan menambahkan elemen tersebut ke bagian paling akhir.

Misalnya:

val names = mutableListOf("Ali", "Jack")

names.add("Sarah")
names.add("Carla")

Hasil akhirnya:

[Ali, Jack, Sarah, Carla]

Perhatikan urutannya:

Awalnya:
[Ali, Jack]

add("Sarah"):
[Ali, Jack, Sarah]

add("Carla"):
[Ali, Jack, Sarah, Carla]

Jadi setiap add() biasa menambahkan elemen ke belakang.

6. Analogi sederhana

Bayangkan ada antrean:

Ali → Jack → George

Kemudian Sarah datang.

Dengan:

names.add("Sarah")

Sarah masuk ke belakang:

Ali → Jack → George → Sarah

Kemudian Carla datang:

names.add("Carla")

menjadi:

Ali → Jack → George → Sarah → Carla

Inilah append:

Tambahkan sesuatu ke bagian belakang.

7. add() juga bisa menerima index

Caption kemudian menyebut bahwa add() memiliki bentuk lain.

Selain:

add(element)

kita juga bisa menggunakan:

add(index, element)

Artinya:

Tambahkan element pada posisi/index tertentu.

Contoh:

val names = mutableListOf(
    "Ali",
    "Jack",
    "George"
)

names.add(1, "Sarah")

Perhatikan:

names.add(1, "Sarah")

Ada dua argument:

1       → index
"Sarah" → element

8. Apa yang terjadi dengan add(1, "Sarah")?

Awalnya:

Index:
  0       1        2
  ↓       ↓        ↓
[Ali]   [Jack]  [George]

Kemudian:

names.add(1, "Sarah")

Kita meminta:

“Masukkan Sarah pada index 1.”

Hasilnya:

Index:
  0       1        2        3
  ↓       ↓        ↓        ↓
[Ali]  [Sarah]  [Jack]  [George]

Perhatikan sesuatu yang penting:

Jack dan George bergeser ke kanan.

Jadi add(index, element) menyisipkan elemen, bukan menggantikan elemen yang sudah ada.

9. Bedakan add(element) dan add(index, element)

Ini sangat penting.

add(element)

names.add("Sarah")

Artinya:

Tambahkan Sarah ke akhir.

Contoh:

[Ali, Jack, George]
             ↓
[Ali, Jack, George, Sarah]

add(index, element)

names.add(1, "Sarah")

Artinya:

Sisipkan Sarah pada index 1.

Hasil:

[Ali, Sarah, Jack, George]

10. Jangan salah mengira add(index, element) sebagai replace

Ini kesalahan yang cukup umum.

Misalnya:

val names = mutableListOf(
    "Ali",
    "Jack",
    "George"
)

Kemudian:

names.add(1, "Sarah")

Bukan menjadi:

[Ali, Sarah, George]

❌ Bukan begitu.

Yang benar:

[Ali, Sarah, Jack, George]

Karena add() menambah elemen baru.

Elemen lama tidak dihapus.

11. Kalau ingin mengganti elemen, itu berbeda

Misalnya kita ingin mengganti:

Jack

menjadi:

Sarah

Kita tidak menggunakan:

add()

Melainkan menggunakan indexing:

names[1] = "Sarah"

Awalnya:

[Ali, Jack, George]

Kemudian:

names[1] = "Sarah"

Hasil:

[Ali, Sarah, George]

Perhatikan perbedaannya:

add()
  ↓
MENAMBAH elemen

list[index] = value
  ↓
MENGGANTI elemen

Ini akan menjadi materi penting berikutnya.

12. += juga bisa digunakan untuk menambahkan

Caption juga menunjukkan alternatif:

array1 += "Carla"

Misalnya:

val names = mutableListOf("Ali", "Jack")

names += "Carla"

Hasilnya:

[Ali, Jack, Carla]

Untuk MutableList, += dapat digunakan sebagai cara singkat untuk menambahkan elemen.

Secara konsep kita bisa membacanya:

names += "Carla"

sebagai:

“Tambahkan Carla ke names.”

13. Bedah operator +=

Kita sudah pernah belajar operator seperti:

x += 5

yang secara konsep berhubungan dengan:

x = x + 5

Untuk collection, penggunaannya bisa terlihat seperti:

names += "Carla"

yang berarti kita ingin menambahkan "Carla" ke collection tersebut.

Jadi kalau melihat kode seperti ini:

names += "Carla"

jangan bingung.

Ini adalah salah satu syntax yang bisa digunakan untuk menambahkan elemen.

14. Contoh add() dan +=

Misalnya:

fun main() {
    val names = mutableListOf(
        "Ali",
        "Jack",
        "George"
    )

    names.add("Sarah")
    names += "Carla"

    println(names)
}

Hasil:

[Ali, Jack, George, Sarah, Carla]

Urutannya:

Awal:
[Ali, Jack, George]

add("Sarah"):
[Ali, Jack, George, Sarah]

+= "Carla":
[Ali, Jack, George, Sarah, Carla]

Jadi Sarah ditambahkan terlebih dahulu, kemudian Carla.

15. Perhatikan bahwa urutan tetap dipertahankan

List adalah collection yang ordered.

Artinya urutan elemen penting.

Misalnya:

val names = mutableListOf("Ali", "Jack")

names.add("Sarah")
names.add("George")

hasil:

[Ali, Jack, Sarah, George]

Bukan:

[George, Sarah, Ali, Jack]

Urutannya mengikuti proses penambahan.

16. Hubungkan dengan sistem registrasi pengguna

Contoh yang digunakan dalam video cukup bagus.

Bayangkan kita membuat aplikasi perusahaan yang memiliki sistem pendaftaran pelanggan.

Awalnya:

val customers = mutableListOf(
    "Budi",
    "Andi"
)

Ada dua customer:

[Budi, Andi]

Kemudian customer baru mendaftar:

customers.add("Citra")

Sekarang:

[Budi, Andi, Citra]

Customer berikutnya:

customers.add("Doni")

menjadi:

[Budi, Andi, Citra, Doni]

Ini alasan mengapa MutableList sangat berguna untuk data yang jumlahnya bisa berubah.

17. Array vs MutableList dalam konteks ini

Ini juga memperjelas kenapa kita sebelumnya belajar MutableList.

Misalnya kita menggunakan Array:

val names = arrayOf("Ali", "Jack")

Ukuran Array bersifat tetap.

Kita tidak bisa melakukan:

names.add("Sarah")

Karena Array tidak memiliki operasi add() seperti MutableList.

Sedangkan:

val names = mutableListOf("Ali", "Jack")

kita bisa:

names.add("Sarah")

Hasil:

[Ali, Jack, Sarah]

Jadi:

18. val bukan berarti MutableList tidak bisa berubah

Ini menghubungkan dengan materi sebelumnya.

Kita sering menulis:

val names = mutableListOf("Ali", "Jack")

Mungkin muncul pertanyaan:

“Bukankah val berarti tidak boleh diubah?”

val berarti variabel names tidak boleh diarahkan ulang ke object lain.

Tetapi object MutableList yang dirujuk oleh names masih bisa dimodifikasi.

Jadi ini boleh:

names.add("Sarah")

Tetapi ini tidak boleh:

names = mutableListOf("George")

Karena yang kedua mencoba mengganti referensi names.

Gambaran:

val names
   │
   ▼
┌─────────────────────┐
│ MutableList          │
│ Ali                  │
│ Jack                 │
└─────────────────────┘
          │
          │ add("Sarah")
          ▼
┌─────────────────────┐
│ MutableList          │
│ Ali                  │
│ Jack                 │
│ Sarah                │
└─────────────────────┘

List-nya berubah, tetapi names tetap menunjuk ke object yang sama.

19. Kenapa disebut “appending”?

Istilah append sering digunakan dalam programming.

Secara sederhana:

append = tambahkan di belakang

Misalnya:

Sebelum:
[A, B, C]

append D

Sesudah:
[A, B, C, D]

Dalam Kotlin:

list.add("D")

adalah cara umum untuk menambahkan elemen ke akhir MutableList.

20. Bagian materi selanjutnya

Di akhir caption, instrukturnya mengatakan bahwa berikutnya akan membahas:

• menambahkan banyak data
• inserting elements
• deleting elements
• melakukan berbagai modifikasi

Jadi sekarang kita baru belajar langkah pertama, yaitu:

➕ Menambahkan elemen ke MutableList.

Kemungkinan konsep berikutnya akan memperdalam perbedaan:

add(element)

dengan:

add(index, element)

serta bagaimana menghapus elemen menggunakan fungsi seperti remove() dan removeAt().

🧠 Ringkasan paling penting

Misalnya:

val names = mutableListOf(
    "Ali",
    "Jack",
    "George"
)

1. Tambahkan ke akhir

names.add("Sarah")

Hasil:

[Ali, Jack, George, Sarah]

Ingat: add(element) → tambah ke belakang.

2. Tambahkan pada index tertentu

names.add(1, "Sarah")

Hasil:

[Ali, Sarah, Jack, George]

Ingat: add(index, element) → sisipkan pada posisi tertentu.

3. Gunakan +=

names += "Sarah"

Hasil:

[Ali, Jack, George, Sarah]

Ini adalah alternatif syntax untuk menambahkan elemen.

4. add() menambah, bukan mengganti

names.add(1, "Sarah")

→ menambahkan Sarah.

Sedangkan:

names[1] = "Sarah"

→ mengganti elemen pada index 1.

Ini dua operasi yang berbeda.

🔑 Cara mengingat

MutableList
    │
    ├── add("Sarah")
    │       ↓
    │   tambah di belakang
    │
    ├── add(1, "Sarah")
    │       ↓
    │   sisipkan di index 1
    │
    └── list[1] = "Sarah"
            ↓
        ganti elemen index 1

Kalau dibuat super singkat:

add() = menambah. add(index, value) = menyisipkan. list[index] = value = mengganti. += = cara singkat untuk menambahkan.

Dan semuanya ini bisa dilakukan karena kita bekerja dengan MutableList, bukan List biasa.