Materi ini sebenarnya adalah lanjutan langsung dari add() pada MutableList. Kalau video sebelumnya membahas menambahkan elemen di akhir List (appending), video ini membahas menyisipkan elemen di posisi tertentu (inserting).

Kunci utama yang perlu kamu pahami adalah:

add(element) → tambah di akhir. add(index, element) → tambah di posisi tertentu.

1. Apa bedanya appending dan inserting?

Misalnya kita punya List:

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

Isinya:

[Ali, Mohammed, Jack, Perla]

Index-nya:

  0        1          2       3
  ↓        ↓          ↓       ↓
[Ali] [Mohammed] [Jack] [Perla]

Sekarang kita ingin menambahkan "Lara".

Ada dua kemungkinan.

A. Tambahkan di akhir

names.add("Lara")

Hasil:

[Ali, Mohammed, Jack, Perla, Lara]

Ini disebut:

Appending

B. Tambahkan di posisi tertentu

Misalnya Lara ingin ditempatkan di antara Jack dan Perla.

Hasil yang kita inginkan:

[Ali, Mohammed, Jack, Lara, Perla]

Kita harus menentukan index tempat Lara dimasukkan.

Inilah yang disebut:

Inserting

2. add() memiliki dua bentuk penting

Untuk MutableList, kita sudah belajar bahwa add() dapat digunakan dengan dua bentuk utama:

Bentuk 1

list.add(element)

Bentuk 2

list.add(index, element)

Perbedaannya sangat penting.

3. Bentuk pertama: add(element)

Contohnya:

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

names.add("Lara")

Karena kita tidak menentukan index, Kotlin menambahkan Lara ke bagian akhir.

Awalnya:

[Ali, Mohammed, Jack, Perla]

Setelah:

names.add("Lara")

menjadi:

[Ali, Mohammed, Jack, Perla, Lara]

Jadi:

Kalau tidak memberikan index, elemen ditambahkan ke akhir List.

4. Bentuk kedua: add(index, element)

Sekarang kita ingin Lara berada di antara Jack dan Perla.

Awalnya:

Index:
  0        1          2       3
  ↓        ↓          ↓       ↓
[Ali] [Mohammed] [Jack] [Perla]

Kita ingin:

[Ali, Mohammed, Jack, Lara, Perla]

Lara harus berada di index:

3

Kenapa index 3?

Karena saat ini:

Jack  → index 2
Perla → index 3

Kalau kita memasukkan Lara sebelum Perla, Lara mengambil posisi index 3.

Maka:

names.add(3, "Lara")

5. Apa yang terjadi setelah add(3, "Lara")?

Awalnya:

  0        1          2       3
  ↓        ↓          ↓       ↓
[Ali] [Mohammed] [Jack] [Perla]

Kita melakukan:

names.add(3, "Lara")

Artinya:

“Sisipkan "Lara" pada index 3.”

Hasil:

  0        1          2        3       4
  ↓        ↓          ↓        ↓       ↓
[Ali] [Mohammed] [Jack] [Lara] [Perla]

Perhatikan bahwa Perla tidak hilang.

Perla yang sebelumnya index 3 sekarang bergeser menjadi index 4.

Ini adalah karakteristik penting dari inserting.

6. add(index, element) bukan mengganti elemen

Ini bagian yang wajib kamu pahami.

Misalnya:

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

Kalau kita melakukan:

names.add(3, "Lara")

hasil:

[Ali, Mohammed, Jack, Lara, Perla]

Bukan:

[Ali, Mohammed, Jack, Lara]

dan bukan:

[Ali, Mohammed, Lara, Perla]

Yang terjadi adalah elemen baru disisipkan, sehingga ukuran List bertambah.

Sebelum:

size = 4

Sesudah:

size = 5

7. Bandingkan add() dengan assignment

Ini akan sangat membantu supaya tidak tertukar.

Misalnya:

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

Menggunakan add()

names.add(3, "Lara")

Hasil:

[Ali, Mohammed, Jack, Lara, Perla]

Jumlah elemen:

5

Karena menambahkan.

Menggunakan assignment

names[3] = "Lara"

Hasil:

[Ali, Mohammed, Jack, Lara]

Jumlah elemen tetap:

4

Karena kita mengganti Perla dengan Lara.

Jadi:

add(index, value)
        ↓
     INSERT
        ↓
 elemen baru masuk
 elemen lama bergeser
 size bertambah


list[index] = value
        ↓
      UPDATE
        ↓
 elemen lama diganti
 size tetap

Ini perbedaan yang sangat penting.

8. Kenapa index 3 berarti sebelum Perla?

Ini mungkin bagian yang agak membingungkan bagi pemula.

Kita punya:

[Ali, Mohammed, Jack, Perla]

Index elemen:

 0       1        2       3
 ↓       ↓        ↓       ↓
Ali  Mohammed   Jack    Perla

Ketika kita mengatakan:

names.add(3, "Lara")

index 3 menjadi posisi tempat Lara dimasukkan.

Elemen yang sebelumnya berada di index 3, yaitu Perla, bergeser ke index 4.

Sehingga:

Sebelum:
index 3 → Perla

add(3, Lara)

Sesudah:
index 3 → Lara
index 4 → Perla

9. Analogi antrean

Bayangkan ada antrean:

Ali → Mohammed → Jack → Perla

Kemudian Lara ingin masuk sebelum Perla.

Maka:

Ali → Mohammed → Jack → Lara → Perla

Lara tidak mengeluarkan Perla dari antrean.

Perla hanya terdorong satu posisi ke belakang.

Itulah gambaran sederhana dari:

names.add(3, "Lara")

10. Contoh lain

Misalnya:

val fruits = mutableListOf(
    "Apple",
    "Banana",
    "Orange"
)

Index:

0       1        2
↓       ↓        ↓
Apple Banana   Orange

Kita ingin menambahkan "Mango" di antara Banana dan Orange.

Maka:

fruits.add(2, "Mango")

Hasil:

[Apple, Banana, Mango, Orange]

Index sekarang:

 0       1        2       3
 ↓       ↓        ↓       ↓
Apple Banana   Mango   Orange

11. Kalau ingin menambahkan di awal?

Karena index pertama adalah 0, kita bisa menggunakan:

list.add(0, element)

Misalnya:

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

names.add(0, "Ali")

Hasil:

[Ali, Jack, Perla]

Karena:

0 → posisi pertama

Jadi:

names.add(0, "Ali")

berarti:

Masukkan Ali di posisi paling awal.

12. Kalau ingin menambahkan di akhir menggunakan index?

Misalnya:

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

Jumlah elemen:

3

Index terakhir:

2

Tetapi untuk menambahkan elemen di akhir, kita bisa menggunakan index:

names.add(3, "Lara")

Hasil:

[Ali, Jack, Perla, Lara]

Kenapa 3?

Karena index 3 adalah posisi setelah index terakhir saat ini.

Namun untuk append biasa, jauh lebih sederhana menggunakan:

names.add("Lara")

Jadi tidak perlu menghitung index secara manual.

13. Contoh lengkap

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

    println(names)

    names.add(3, "Lara")

    println(names)
}

Output:

[Ali, Mohammed, Jack, Perla]
[Ali, Mohammed, Jack, Lara, Perla]

Perubahan yang terjadi:

SEBELUM

0       1          2       3
↓       ↓          ↓       ↓
Ali  Mohammed    Jack    Perla


add(3, "Lara")


SESUDAH

0       1          2       3      4
↓       ↓          ↓       ↓      ↓
Ali  Mohammed    Jack    Lara   Perla

14. Apa arti masing-masing argument?

Saat melihat:

names.add(3, "Lara")

jangan sampai terbalik.

Ada dua argument:

names.add(3, "Lara")
          ↑      ↑
          │      │
        index  element

Argument pertama:

3

adalah:

Di mana elemen akan dimasukkan?

Argument kedua:

"Lara"

adalah:

Apa yang ingin dimasukkan?

Jadi cara membacanya:

“Masukkan Lara pada index 3.”

15. Jangan sampai terbalik

Jangan menulis:

names.add("Lara", 3)

❌ Urutannya salah.

Yang benar:

names.add(3, "Lara")

Karena signature-nya:

add(index, element)

Bukan:

add(element, index)

16. Hubungkan dengan materi sebelumnya

Sekarang kalau kita gabungkan materi-materi sebelumnya, kita sudah punya banyak kemampuan untuk bekerja dengan List.

Misalnya:

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

Mengecek jumlah

names.size

Mengecek apakah kosong

names.isEmpty()

Mengambil pertama

names.first()

Mengambil terakhir

names.last()

Mengambil berdasarkan index

names[1]

Mengecek apakah elemen ada

"Jack" in names

Menambahkan ke akhir

names.add("Lara")

Menambahkan di posisi tertentu

names.add(1, "Lara")

Mengganti elemen

names[1] = "Lara"

Jadi kita mulai bisa benar-benar mengelola isi List.

17. Visualisasi semua operasi

Misalnya awalnya:

[Ali, Jack, Perla]
  0     1      2

add("Lara")

Tambah di akhir:

[Ali, Jack, Perla, Lara]
  0     1      2      3

add(1, "Lara")

Sisipkan di index 1:

[Ali, Lara, Jack, Perla]
  0     1     2      3

[1] = "Lara"

Ganti index 1:

[Ali, Lara, Perla]
  0     1      2

Perhatikan bahwa hasilnya berbeda.

18. Kesalahan umum pemula

❌ Kesalahan 1: menganggap index dimulai dari 1

Misalnya:

Ali      = 1
Mohammed = 2
Jack     = 3
Perla    = 4

Itu cara manusia menghitung posisi.

Kotlin menggunakan:

Ali      = 0
Mohammed = 1
Jack     = 2
Perla    = 3

Jadi selalu ingat:

Index dimulai dari 0.

❌ Kesalahan 2: mengira add(index, value) mengganti

names.add(2, "Lara")

bukan mengganti elemen index 2.

Itu menyisipkan elemen baru.

❌ Kesalahan 3: lupa bahwa elemen setelahnya bergeser

Sebelum:

[A, B, C, D]

Lakukan:

list.add(1, "X")

Hasil:

[A, X, B, C, D]

Bukan:

[A, X, C, D]

B, C, dan D tidak hilang. Mereka bergeser.

19. Perbedaan “append” dan “insert”

Ini inti dari seluruh video.

Append

Menambahkan elemen ke akhir.

names.add("Lara")

Visual:

[A, B, C]
       ↓
[A, B, C, Lara]

Insert

Menambahkan elemen ke posisi tertentu.

names.add(1, "Lara")

Visual:

[A, B, C]
    ↓
[A, Lara, B, C]

🧠 Cara mengingat

Bayangkan sebuah antrean:

Ali → Mohammed → Jack → Perla

Kalau orang baru datang dan langsung masuk paling belakang:

names.add("Lara")

Hasil:

Ali → Mohammed → Jack → Perla → Lara

APPEND = masuk belakang.

Kalau Lara ingin masuk di posisi tertentu:

names.add(3, "Lara")

Hasil:

Ali → Mohammed → Jack → Lara → Perla

INSERT = masuk ke posisi tertentu.

🔑 Rumus yang perlu kamu hafalkan

add(element)
     ↓
tambahkan ke akhir


add(index, element)
     ↓
tambahkan pada index tertentu

Dan jangan tertukar dengan:

list[index] = element
     ↓
mengganti elemen yang sudah ada

Jadi kalau kamu melihat:

names.add(3, "Lara")

langsung pikir:

“Index 3 adalah tempatnya, Lara adalah barang yang dimasukkan.”

Sedangkan kalau:

names.add("Lara")

langsung pikir:

“Tidak ada index → tambahkan Lara ke paling belakang.”