Di materi ini kita melanjutkan pembahasan modifying MutableList, khususnya bagaimana menghapus elemen dari List/Array.

Kalau sebelumnya kita sudah belajar:

• add(element) → menambahkan di akhir
• add(index, element) → menyisipkan di posisi tertentu
• list[index] = value → mengganti nilai

Sekarang kita belajar:

• remove(element) → menghapus berdasarkan nilai
• removeAt(index) → menghapus berdasarkan posisi/index

1. Gambaran besarnya

Misalnya kita punya:

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

Posisinya:

Index:      0          1          2       3
            ↓          ↓          ↓       ↓
Names:    [Ali,    Muhammad,    Jack,   Perla]

Sekarang kita ingin menghapus "Jack".

Ada dua cara utama:

Berdasarkan nilai

names.remove("Jack")

Artinya:

“Cari elemen yang nilainya Jack, lalu hapus.”

Berdasarkan index

names.removeAt(2)

Artinya:

“Hapus elemen yang berada di index 2.”

Karena Jack berada di index 2, hasilnya sama.

2. remove(element)

Ini adalah cara menghapus berdasarkan isi/nilai elemen.

Contoh:

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

names.remove("Jack")

println(names)

Hasil:

[Ali, Muhammad, Perla]

Sebelumnya:

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

Setelah:

Index:  0          1          2
        ↓          ↓          ↓
      [Ali,    Muhammad,    Perla]

Jack sudah hilang.

3. Kenapa index setelah remove() berubah?

Ini penting.

Ketika kita menghapus elemen dari tengah List, elemen setelahnya akan bergeser ke kiri.

Misalnya:

Sebelum:

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

Kita jalankan:

names.remove("Jack")

Maka Jack hilang.

Perla yang tadinya index 3 bergeser menjadi index 2.

Sesudah:

0       1       2
↓       ↓       ↓
Ali   Muhammad Perla

Jadi jangan menganggap index elemen akan selalu tetap.

4. remove() mengembalikan Boolean

Ini salah satu bagian paling penting dari materi.

Ketika kita menulis:

names.remove("Jack")

method remove() tidak hanya menghapus elemen.

Dia juga mengembalikan nilai Boolean:

true

atau

false

true

Berarti:

Elemen ditemukan dan berhasil dihapus.

false

Berarti:

Elemen tidak ditemukan, sehingga tidak ada yang dihapus.

Contoh true

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

val result = names.remove("Jack")

println(result)

Output:

true

Kenapa true?

Karena "Jack" memang ada:

[Ali, Muhammad, Jack, Perla]
             ↑
          ditemukan

Kemudian dihapus.

5. Contoh false

Sekarang kita coba:

val result = names.remove("Fatty")

println(result)

Misalnya List kita:

[Ali, Muhammad, Perla]

Tidak ada "Fatty".

Maka:

result = false

Karena:

"Fatty" ❌ tidak ditemukan

Tidak ada yang dihapus.

6. Kenapa return true atau false berguna?

Ini berguna ketika kita ingin memastikan apakah penghapusan berhasil atau tidak.

Misalnya dalam aplikasi kita punya daftar pelanggan:

val customers = mutableListOf(
    "Ali",
    "Budi",
    "Citra"
)

Kita ingin menghapus "Budi".

val removed = customers.remove("Budi")

if (removed) {
    println("Customer berhasil dihapus")
} else {
    println("Customer tidak ditemukan")
}

Kalau Budi ada:

Customer berhasil dihapus

Kalau Budi tidak ada:

Customer tidak ditemukan

Jadi Boolean dari remove() bisa digunakan sebagai indikator keberhasilan.

7. remove() tidak menghapus berdasarkan index

Perhatikan perbedaan ini.

names.remove("Jack")

Artinya:

Cari nilai "Jack" dan hapus.

Sedangkan:

names.removeAt(2)

Artinya:

Hapus elemen di index 2.

Ini dua konsep yang berbeda.

8. removeAt(index)

Sekarang kita masuk ke cara kedua.

removeAt(index)

Method ini digunakan untuk menghapus elemen berdasarkan index.

Misalnya:

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

Posisinya:

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

Kita ingin menghapus "Ali".

Ali berada di index 0.

Maka:

names.removeAt(0)

Hasil:

[Muhammad, Jack, Perla]

9. Apa yang terjadi setelah removeAt(0)?

Sebelum:

0          1       2
↓          ↓       ↓
Ali      Jack    Perla

Kita:

names.removeAt(0)

Ali dihapus.

Kemudian elemen lainnya bergeser:

0       1
↓       ↓
Jack   Perla

Jadi:

• Jack sebelumnya index 1
• setelah Ali dihapus, Jack menjadi index 0

Begitu juga Perla.

10. Contoh lengkap

fun main() {

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

    println(names)

    names.remove("Jack")

    println(names)

    names.removeAt(0)

    println(names)
}

Output kira-kira:

[Ali, Muhammad, Jack, Perla]

[Ali, Muhammad, Perla]

[Muhammad, Perla]

Urutannya:

Awalnya

[Ali, Muhammad, Jack, Perla]

remove("Jack")

[Ali, Muhammad, Perla]

removeAt(0)

[Muhammad, Perla]

11. Perbedaan remove() dan removeAt()

Ini bagian yang wajib benar-benar dipahami.

Contoh:

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

Index:

0      1       2
↓      ↓       ↓
Ali   Jack    Perla

Berdasarkan nilai

names.remove("Jack")

Kita tidak peduli Jack berada di index berapa.

Kita bilang:

“Cari Jack.”

Berdasarkan index

names.removeAt(1)

Kita tidak peduli siapa orangnya.

Kita bilang:

“Hapus siapa pun yang berada di posisi 1.”

12. Analogi sederhana

Bayangkan List sebagai antrean:

Posisi:

0       1        2        3
↓       ↓        ↓        ↓

Ali   Budi     Citra     Doni

remove("Citra")

Kita bilang:

“Citra, keluar dari antrean.”

Kita mencari orangnya.

removeAt(2)

Kita bilang:

“Orang yang berada di posisi nomor 2, keluar.”

Kita mencari berdasarkan posisinya.

13. Hati-hati dengan removeAt()

Karena removeAt() menggunakan index, kita harus memberikan index yang valid.

Misalnya:

val names = mutableListOf(
    "Ali",
    "Budi",
    "Citra"
)

Index yang tersedia:

0      1       2
↓      ↓       ↓
Ali   Budi    Citra

Ini valid:

names.removeAt(0)
names.removeAt(1)
names.removeAt(2)

selama List masih memiliki elemen pada index tersebut.

Tetapi:

names.removeAt(3)

akan error karena index 3 tidak ada.

Ingat:

Index terakhir = size - 1

Kalau jumlah elemen 3:

size = 3
last index = 3 - 1 = 2

14. Bagaimana dengan Array?

Di bagian awal caption disebut “array or list”, tetapi ada hal penting dalam Kotlin:

Untuk menghapus elemen, yang umum digunakan adalah MutableList, karena ukuran Array bersifat tetap.

Misalnya:

val numbers = arrayOf(10, 20, 30)

Array memiliki ukuran:

10, 20, 30
↑
3 elemen

Kita tidak bisa begitu saja melakukan:

numbers.remove(20)

seperti pada MutableList.

Kenapa?

Karena Array memiliki ukuran tetap.

Kalau mau koleksi yang bisa:

• add
• remove
• removeAt
• dan berubah ukurannya

gunakan:

MutableList

Contohnya:

val numbers = mutableListOf(10, 20, 30)

Sekarang:

numbers.remove(20)

bisa dilakukan.

15. Hubungkan dengan materi sebelumnya

Sekarang kita sudah punya beberapa operasi penting untuk MutableList.

Misalnya:

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

Menambahkan di akhir

names.add("Perla")

Hasil:

[Ali, Muhammad, Jack, Perla]

Menambahkan di posisi tertentu

names.add(2, "Sarah")

Hasil:

[Ali, Muhammad, Sarah, Jack, Perla]

Mengubah elemen

names[2] = "Lara"

Hasil:

[Ali, Muhammad, Lara, Jack, Perla]

Jumlah elemen tidak berubah.

Menghapus berdasarkan nilai

names.remove("Jack")

Hasil:

[Ali, Muhammad, Lara, Perla]

Menghapus berdasarkan index

names.removeAt(0)

Hasil:

[Muhammad, Lara, Perla]

16. Perhatikan perbedaan add, assignment, dan remove

Ini sering membingungkan pemula.

Misalnya:

val names = mutableListOf(
    "Ali",
    "Budi",
    "Citra"
)

add()

names.add("Doni")

Menambah elemen.

[Ali, Budi, Citra, Doni]

Jumlah:

3 → 4

names[index] = value

names[1] = "Eka"

Mengganti elemen.

[Ali, Eka, Citra, Doni]

Jumlah:

4 → 4

Tidak berubah.

remove()

names.remove("Eka")

Menghapus berdasarkan nilai.

[Ali, Citra, Doni]

Jumlah:

4 → 3

removeAt()

names.removeAt(0)

Menghapus berdasarkan index.

[Citra, Doni]

Jumlah:

3 → 2

17. Satu hal menarik: remove() mencari nilainya

Misalnya:

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

Kemudian:

names.remove("Jack")

Yang dihapus adalah satu instance/kemunculan yang cocok, yaitu satu Jack, bukan semua Jack.

Hasilnya akan menjadi:

[Ali, Jack, Perla]

Jadi remove() bukan berarti:

“Hapus semua elemen yang bernama Jack.”

Tetapi lebih tepat:

“Hapus satu elemen pertama yang cocok dengan nilai yang diberikan.”

Kalau ingin menghapus semua kemunculan, nanti ada teknik lain yang bisa dipelajari.

18. remove() menghasilkan Boolean

Kita bisa langsung menggunakan hasilnya:

if (names.remove("Jack")) {
    println("Jack berhasil dihapus")
} else {
    println("Jack tidak ditemukan")
}

Ini sangat berguna dalam program nyata.

Misalnya sistem mempunyai:

Daftar pelanggan
       ↓
[Ali, Budi, Citra]

Kita mencoba menghapus:

names.remove("Budi")

Kalau berhasil:

true

Program tahu:

Budi memang ada dan sudah dihapus.

Kalau:

names.remove("Doni")

dan Doni tidak ada:

false

Program tahu:

Doni tidak ada di dalam List.

19. Ringkasan visual

Bayangkan kita memiliki:

Index:    0       1       2       3
          ↓       ↓       ↓       ↓
        [Ali,   Budi,   Citra,  Doni]

Tambah di akhir

names.add("Eka")

[Ali, Budi, Citra, Doni, Eka]

Tambah di posisi tertentu

names.add(1, "Eka")

[Ali, Eka, Budi, Citra, Doni]

Ganti

names[1] = "Fajar"

[Ali, Fajar, Budi, Citra, Doni]

Hapus berdasarkan nilai

names.remove("Budi")

[Ali, Fajar, Citra, Doni]

Hapus berdasarkan index

names.removeAt(1)

[Ali, Citra, Doni]

20. Cheat sheet

Cara paling mudah mengingat:

add("X")
   ↓
"TAMBAHKAN X"

add(2, "X")
   ↓
"TAMBAHKAN X DI INDEX 2"

list[2] = "X"
   ↓
"GANTI ISI INDEX 2 DENGAN X"

remove("X")
   ↓
"CARI X, LALU HAPUS"

removeAt(2)
   ↓
"HAPUS YANG ADA DI INDEX 2"

Inti materi hari ini: remove() digunakan ketika kita tahu nilai yang ingin dihapus, sedangkan removeAt() digunakan ketika kita tahu posisi/index yang ingin dihapus. Dan remove() mengembalikan Boolean: true kalau berhasil menghapus, false kalau elemen tidak ditemukan.