Materi kali ini membahas List di Kotlin. Konsepnya memang mirip dengan Array, tetapi ada satu perbedaan besar yang harus benar-benar kamu pahami:

Array → ukuran tetap (fixed size) List → bisa dibuat dinamis, terutama MutableList

Mari kita bahas pelan-pelan dari dasar.

1. Apa itu List?

Kalau sebelumnya kita belajar Array:

val planets = arrayOf("Mercury", "Earth", "Mars")

Sekarang Kotlin juga punya List:

val planets = listOf("Mercury", "Earth", "Mars")

Secara sederhana, keduanya sama-sama merupakan wadah untuk menyimpan banyak data.

Misalnya:

Array:
[Mercury, Earth, Mars]

List:
[Mercury, Earth, Mars]

Keduanya juga mempunyai urutan dan index.

Index:
   0          1        2
   ↓          ↓        ↓
Mercury    Earth     Mars

Jadi kita bisa mengambil:

println(planets[0])

hasil:

Mercury

2. Perbedaan paling penting: Array vs List

Ini bagian yang paling penting dari materi.

Array memiliki ukuran tetap

Misalnya:

val planets = arrayOf("Mercury", "Earth", "Mars")

Array ini memiliki 3 elemen.

Secara sederhana:

┌─────────┬─────────┬────────┐
│ Mercury │  Earth  │  Mars  │
└─────────┴─────────┴────────┘
     0         1         2

Ukuran array tersebut adalah 3.

Kita bisa mengganti:

planets[0] = "Venus"

tetapi kita tidak bisa begitu saja menambahkan elemen ke-4 sehingga array menjadi lebih besar.

3. List lebih fleksibel

List memiliki konsep yang lebih fleksibel.

Terutama ketika menggunakan:

MutableList

Kita dapat:

• menambahkan data
• menghapus data
• menyisipkan data
• mengubah data
• dan sebagainya

Misalnya:

val planets = mutableListOf("Mercury", "Earth", "Mars")

Awalnya:

[Mercury, Earth, Mars]

Kemudian kita bisa menambahkan:

planets.add("Jupiter")

Sekarang:

[Mercury, Earth, Mars, Jupiter]

Kemudian kita bisa menghapus:

planets.remove("Earth")

Hasilnya:

[Mercury, Mars, Jupiter]

Jadi ukurannya dapat berubah.

4. Analogi sederhana: Array vs List

Bayangkan kamu memiliki rak buku.

Array

Rak Array seperti rak yang sudah dibuat dengan jumlah slot tertentu.

Misalnya:

┌────────┬────────┬────────┐
│ Buku 1 │ Buku 2 │ Buku 3 │
└────────┴────────┴────────┘

Kamu bisa mengganti Buku 1 dengan buku lain.

Tetapi jumlah slot rak tetap 3.

MutableList

MutableList seperti rak yang bisa ditambah atau dikurangi kapasitasnya sesuai kebutuhan.

Awalnya:

┌────────┬────────┬────────┐
│ Buku 1 │ Buku 2 │ Buku 3 │
└────────┴────────┴────────┘

Tambah buku:

┌────────┬────────┬────────┬────────┐
│ Buku 1 │ Buku 2 │ Buku 3 │ Buku 4 │
└────────┴────────┴────────┴────────┘

Hapus buku:

┌────────┬────────┬────────┐
│ Buku 1 │ Buku 3 │ Buku 4 │
└────────┴────────┴────────┘

Inilah ide dynamic size.

5. Membuat List dengan listOf()

Cara sederhana membuat List:

val planets = listOf("Mercury", "Earth", "Mars")

Kotlin akan mengetahui bahwa semua datanya adalah String.

Jadi tipe yang disimpulkan adalah:

List<String>

Kita tidak harus menulis:

val planets: List<String> = listOf(...)

karena Kotlin sudah bisa melakukan type inference.

6. Apa itu List<String>?

Sama seperti pembahasan Array sebelumnya, <String> menunjukkan tipe data yang disimpan.

List<String>

artinya:

List yang berisi String.

Sedangkan:

List<Int>

berarti:

List yang berisi Int.

Contoh:

val names = listOf("Budi", "Andi", "Citra")

→ List<String>

Dan:

val ages = listOf(20, 25, 30)

→ List<Int>

7. List juga harus memiliki tipe yang sesuai

Misalnya:

val names = listOf("Budi", "Andi", "Citra")

Kotlin mengetahui:

List<String>

Karena semua elemen berupa String.

Kita tidak bisa membuat List seperti:

["Budi", 20, true]

jika Kotlin mengharapkan List<String>.

Konsepnya sama seperti Array:

Collection memiliki tipe elemen yang harus sesuai.

8. Kenapa tidak perlu menulis <String>?

Di versi Kotlin yang lebih modern, kita bisa menulis:

val planets = listOf("Mercury", "Earth", "Mars")

Kotlin melihat:

"Mercury" → String
"Earth"   → String
"Mars"    → String

Kemudian Kotlin menyimpulkan:

List<String>

Ini disebut type inference.

Jadi compiler seperti berkata:

“Saya lihat semua isinya String. Berarti ini List<String>.”

9. Kalau ingin menuliskan tipe secara eksplisit

Boleh juga:

val planets: List<String> =
    listOf("Mercury", "Earth", "Mars")

Di sini kita sendiri mengatakan:

planets
   ↓
List<String>

Biasanya tidak perlu jika Kotlin sudah bisa mengetahuinya.

10. Apa bedanya listOf() dan arrayListOf()?

Transcript juga memperkenalkan:

arrayListOf()

dan:

listOf()

Contohnya:

val planets = listOf("Mercury", "Earth", "Mars")

atau:

val planets = arrayListOf("Mercury", "Earth", "Mars")

Keduanya berhubungan dengan konsep List, tetapi ada perbedaan pada tipe/implementasi konkretnya.

Kamu bisa membayangkan:

List
 ↓
interface / kontrak
 ↓
bisa memiliki berbagai implementasi

Implementasinya bisa berupa:

ArrayList
LinkedList
dan lainnya

Jadi ketika kita menulis:

val planets: List<String>

kita mengatakan:

“Saya membutuhkan sesuatu yang memenuhi kontrak List.”

Kita tidak terlalu peduli implementasi internalnya.

11. Apa itu interface?

Ini sedikit masuk ke konsep Object-Oriented Programming.

Transcript mengatakan:

List di Kotlin adalah sebuah interface.

Untuk sekarang bayangkan interface sebagai kontrak.

Misalnya ada kontrak:

LIST
- bisa mengambil elemen
- memiliki urutan
- memiliki index
- memiliki ukuran
- dll.

Kemudian ada berbagai implementasi yang memenuhi kontrak tersebut:

              List
               │
       ┌───────┴────────┐
       ↓                ↓
   ArrayList         implementasi lain

Jadi:

List<String>

lebih menggambarkan kemampuan/kontrak yang kita butuhkan.

Sedangkan:

ArrayList<String>

lebih spesifik terhadap implementasi.

Untuk pemula, tidak perlu terlalu dalam dulu mengenai interface. Yang penting pahami perbedaan interface vs implementasi ini karena nanti akan sering muncul di Kotlin.

12. Mengapa biasanya kita memilih listOf()?

Transcript menyarankan lebih memilih:

listOf()

daripada langsung:

arrayListOf()

Alasannya adalah kita biasanya ingin bekerja berdasarkan apa yang bisa dilakukan oleh collection, bukan bergantung pada implementasi spesifiknya.

Misalnya:

val planets = listOf("Mercury", "Earth", "Mars")

Kita cukup mengatakan:

“Saya punya sebuah List.”

Tidak perlu mengatakan:

“Saya harus menggunakan ArrayList.”

Ini membuat kode lebih fleksibel.

13. listOf() menghasilkan List yang tidak bisa dimodifikasi

Nah, ini konsep yang sangat penting.

Misalnya:

val planets = listOf("Mercury", "Earth", "Mars")

Kita tidak bisa melakukan:

planets.add("Jupiter")

atau:

planets.remove("Earth")

Karena listOf() menghasilkan read-only List.

Transcript menggunakan istilah:

immutable

Namun secara konsep untuk pemula, lebih aman memahami listOf() sebagai List yang tidak menyediakan operasi modifikasi melalui tipe List.

Jadi:

listOf(...)

cocok ketika data tidak perlu kita ubah.

14. Contoh penggunaan listOf()

Misalnya daftar planet:

val planets = listOf(
    "Mercury",
    "Venus",
    "Earth",
    "Mars"
)

Kita bisa membaca data:

println(planets[0])

Output:

Mercury

Kita juga bisa mengetahui jumlah elemen:

println(planets.size)

Output:

4

Tetapi kita tidak bisa:

planets.add("Jupiter")

Karena ini bukan mutable list.

15. Bagaimana membuat Empty List?

Kita juga bisa membuat List kosong.

Misalnya:

val emptyList = listOf<String>()

Hasilnya:

[]

Tetapi tipenya tetap:

List<String>

Ini penting karena List tersebut kosong sehingga Kotlin tidak bisa mengetahui tipenya dari elemen.

16. Kenapa List kosong membutuhkan <String>?

Perhatikan:

val planets = listOf("Mercury", "Earth", "Mars")

Kotlin bisa melihat:

"Mercury"

dan langsung tahu:

String

Tetapi kalau:

val planets = listOf()

Kotlin melihat:

tidak ada elemen

Pertanyaannya:

“Ini List berisi apa?”

String?

List<String>

Int?

List<Int>

Boolean?

List<Boolean>

Kotlin tidak bisa mengetahui jawabannya hanya dari isi List karena memang tidak ada isinya.

Oleh karena itu kita bisa memberikan tipe:

val planets = listOf<String>()

Sekarang Kotlin tahu:

planets
   ↓
List<String>
   ↓
[]

17. Alternatif penulisan

Kita juga bisa menulis:

val planets: List<String> = listOf()

atau:

val planets = listOf<String>()

Keduanya memberitahu Kotlin bahwa List tersebut berisi String.

18. Sekarang masuk ke MutableList

Ini bagian yang sangat penting.

Kalau kita ingin List yang dapat diubah, gunakan:

mutableListOf()

Contoh:

val planets = mutableListOf("Mercury", "Earth", "Mars")

Sekarang kita mempunyai MutableList.

Mutable berarti:

bisa diubah.

19. Menambahkan elemen ke MutableList

Misalnya:

val planets = mutableListOf("Mercury", "Earth", "Mars")

Kemudian:

planets.add("Jupiter")

Sekarang:

Sebelum:

[Mercury, Earth, Mars]


Sesudah:

[Mercury, Earth, Mars, Jupiter]

Ukuran List berubah dari:

3

menjadi:

4

Inilah yang dimaksud dynamic size.

20. Menghapus elemen

Kita juga bisa menghapus:

planets.remove("Earth")

Sebelumnya:

[Mercury, Earth, Mars, Jupiter]

Sesudah:

[Mercury, Mars, Jupiter]

Jadi MutableList bisa tumbuh dan menyusut.

add()
 ↓
bertambah

remove()
 ↓
berkurang

21. Mengubah elemen

MutableList juga bisa mengubah elemen berdasarkan index.

val planets = mutableListOf("Mercury", "Earth", "Mars")

planets[1] = "Venus"

Sebelumnya:

[Mercury, Earth, Mars]

Sesudah:

[Mercury, Venus, Mars]

Karena index 1 berisi "Earth".

22. Membuat MutableList kosong

Kita juga bisa membuat MutableList kosong:

val names = mutableListOf<String>()

Hasil awal:

[]

Tetapi tipe datanya:

MutableList<String>

Kemudian kita bisa mengisinya:

names.add("Budi")
names.add("Andi")
names.add("Citra")

Sekarang:

[Budi, Andi, Citra]

23. Kenapa Empty MutableList perlu <String>?

Sama seperti sebelumnya.

Kalau kita menulis:

val names = mutableListOf()

Kotlin tidak punya elemen untuk dijadikan petunjuk tipe.

Jadi kita bisa memberitahunya:

val names = mutableListOf<String>()

Artinya:

Buat MutableList kosong yang nantinya berisi String.

Kemudian:

names.add("Budi")

boleh.

Tetapi:

names.add(100)

tidak boleh karena 100 adalah Int, bukan String.

24. Perbedaan List dan MutableList

Ini wajib kamu hafalkan.

Contoh:

val names = listOf("Ali", "Budi")

vs:

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

25. Analogi List vs MutableList

Bayangkan kamu memiliki daftar peserta ujian.

List

Daftar peserta:
1. Budi
2. Andi
3. Citra

Daftar tersebut hanya ingin kamu baca.

val students = listOf("Budi", "Andi", "Citra")

Tidak perlu menambahkan atau menghapus peserta.

MutableList

Sekarang bayangkan daftar peserta masih bisa berubah.

Hari ini:

[Budi, Andi, Citra]

Besok ada peserta baru:

[Budi, Andi, Citra, Doni]

Maka gunakan:

val students = mutableListOf("Budi", "Andi", "Citra")

students.add("Doni")

26. val tidak berarti List immutable

Ini sering membingungkan karena kita sebelumnya belajar val.

Perhatikan:

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

Walaupun menggunakan:

val

kita masih bisa:

names.add("Citra")

Kenapa?

Karena val mengatur referensi variabel, bukan otomatis membuat object yang ditunjuk menjadi immutable.

Secara sederhana:

val names
    │
    ↓
MutableList
[Budi, Andi]

Kita tidak boleh membuat:

names = mutableListOf("Doni")

Tetapi kita boleh mengubah isi:

names.add("Citra")

Jadi:

val ≠ immutable object.

27. Array vs List vs MutableList

Sekarang kita bandingkan semuanya.

Catatan: “List ❌ ukuran berubah” di sini maksudnya List read-only yang dibuat lewat listOf() tidak menyediakan operasi perubahan ukuran.

28. Bagaimana memilihnya?

Gunakan pertanyaan sederhana:

“Apakah saya membutuhkan collection yang bisa berubah ukurannya?”

Kalau tidak:

val names = listOf("Budi", "Andi", "Citra")

Kalau ya:

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

Kalau memang membutuhkan Array dengan ukuran tetap:

val names = arrayOf("Budi", "Andi", "Citra")

29. Kenapa tidak selalu menggunakan MutableList?

Karena prinsip pemrograman yang baik adalah:

Jangan memberikan kemampuan lebih dari yang dibutuhkan.

Misalnya data tidak perlu diubah:

val planets = listOf("Mercury", "Earth", "Mars")

Lebih jelas daripada:

val planets = mutableListOf("Mercury", "Earth", "Mars")

Dengan List, kode kita menyatakan:

“Data ini hanya perlu dibaca.”

Dengan MutableList, kode kita menyatakan:

“Data ini boleh dimodifikasi.”

Ini membuat maksud kode lebih jelas dan membantu mencegah perubahan yang tidak disengaja.

30. Gambaran struktur konsepnya

Coba simpan gambaran ini di kepala:

                 Collection
                     │
        ┌────────────┴────────────┐
        │                         │
      Array                     List
        │                         │
   fixed size              ┌──────┴──────┐
                            │             │
                        List (read)   MutableList
                                      │
                                bisa berubah

Dan function yang biasa digunakan:

arrayOf()
   ↓
Array

listOf()
   ↓
List

mutableListOf()
   ↓
MutableList

31. Contoh lengkap

Misalnya kita membuat aplikasi yang menyimpan daftar nama.

Read-only

val names = listOf("Budi", "Andi", "Citra")

println(names[0])
println(names[1])
println(names[2])

Output:

Budi
Andi
Citra

Kalau mencoba:

names.add("Doni")

❌ Tidak bisa.

Mutable

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

names.add("Doni")
names.remove("Andi")
names[0] = "Bayu"

println(names)

Hasil akhirnya:

[Bayu, Citra, Doni]

Di sini kita sudah melakukan tiga operasi:

add()       → menambahkan
remove()    → menghapus
[index] =   → mengubah

32. Satu konsep yang sangat penting: “List” bukan berarti selalu mutable

Jangan berpikir:

“Kalau namanya List, berarti bisa ditambah dan dihapus.”

Tidak selalu.

Ada:

List<T>

dan:

MutableList<T>

Perbedaannya:

List
 ↓
baca data

MutableList
 ↓
baca + ubah data

Ini sangat penting dalam Kotlin.

33. Ringkasan materi

Kalau kita sederhanakan seluruh video:

Array

val numbers = arrayOf(1, 2, 3)

• ukuran tetap
• memiliki index
• elemen terurut
• tipe elemen harus sesuai

List

val numbers = listOf(1, 2, 3)

• memiliki index
• terurut
• digunakan untuk membaca collection
• tidak menyediakan operasi modifikasi seperti add()/remove()

MutableList

val numbers = mutableListOf(1, 2, 3)

• memiliki index
• terurut
• bisa menambah elemen
• bisa menghapus elemen
• bisa mengubah elemen
• ukurannya dapat berubah

🧠 Cara paling gampang mengingat

Bayangkan tiga jenis wadah:

Array
📦📦📦
"Slot sudah ditentukan."

List
📋
"Daftar yang saya baca."

MutableList
📋✏️
"Daftar yang bisa saya edit."

Atau cukup ingat:

Array = fixed size List = read-only MutableList = bisa berubah

Dan tiga function utamanya:

arrayOf(...)          // Array
listOf(...)           // List
mutableListOf(...)    // MutableList

Satu catatan kecil: transcript menyebut List lebih lambat dan Array lebih cepat secara umum. Jangan menjadikannya aturan mutlak. Performa bergantung pada operasi dan implementasinya. Untuk sekarang, jauh lebih penting memahami perbedaan kemampuan dan ukuran antara Array, List, dan MutableList.