Materi ini mulai masuk ke Collection Types di Kotlin, dan pada bagian ini fokusnya adalah Array. Saya jelaskan dari konsep paling dasar sampai bagian IntArray, boxing/unboxing, dan perbedaan Array<Int> dengan IntArray.

1. Apa itu Collection?

Sebelumnya kita banyak bekerja dengan satu nilai:

val name = "Budi"
val age = 20

Masing-masing variabel menyimpan satu nilai.

Sekarang bayangkan kita ingin menyimpan banyak data sekaligus:

10
20
30
40
50

Daripada membuat:

val number1 = 10
val number2 = 20
val number3 = 30
val number4 = 40
val number5 = 50

Kita bisa menggunakan collection.

Collection adalah wadah untuk menyimpan banyak nilai.

Di Kotlin ada beberapa collection yang akan dipelajari:

• Array
• List
• Map
• Set

Selain itu, biasanya juga akan dibahas Lambda, karena lambda banyak digunakan ketika bekerja dengan collection.

Untuk materi ini, kita fokus ke:

Array

2. Apa itu Array?

Array adalah sebuah kumpulan nilai yang:

1. memiliki urutan (ordered)
2. berisi tipe data yang sama
3. setiap elemennya memiliki index
4. index dimulai dari 0

Contohnya:

val names = arrayOf("Ali", "Bob", "Charlie", "David")

Array tersebut berisi:

Ali
Bob
Charlie
David

Secara konsep bisa dibayangkan seperti kotak-kotak:

Index:     0       1         2          3
         ┌─────┬─────┬─────────┬─────────┐
Value:   │ Ali │ Bob │ Charlie │ David   │
         └─────┴─────┴─────────┴─────────┘

Setiap nilai mempunyai posisi yang disebut index.

3. Array hanya berisi tipe yang sama

Ini adalah konsep yang sangat penting.

Misalnya:

val names = arrayOf("Ali", "Bob", "Charlie")

Karena semua elemennya adalah String, maka array tersebut bertipe:

Array<String>

Kita tidak bisa sembarangan memasukkan Int ke dalamnya.

Misalnya:

val names = arrayOf("Ali", "Bob", "Charlie")

names[0] = 100

Ini akan menjadi error karena:

names → Array<String>

sedangkan:

100 → Int

Jadi tipe datanya tidak cocok.

4. Kenapa Array disebut type-safe?

Kotlin sangat memperhatikan type safety.

Artinya, Kotlin berusaha memastikan kita tidak memasukkan tipe data yang salah.

Misalnya:

val oddNumbers = arrayOf(1, 3, 5, 7, 9)

Kotlin melihat semua data tersebut berupa Int.

Maka Kotlin mengetahui:

oddNumbers: Array<Int>

Kalau kita mencoba:

oddNumbers[0] = "Hello"

Kotlin akan memberikan error saat compile time.

Artinya error diketahui sebelum program dijalankan.

Ini jauh lebih baik daripada baru mengetahui kesalahan ketika aplikasi sedang berjalan.

5. Index Array dimulai dari 0

Ini salah satu hal yang wajib diingat ketika belajar programming.

Kotlin menggunakan zero-based indexing.

Artinya:

Elemen pertama  → index 0
Elemen kedua    → index 1
Elemen ketiga   → index 2
Elemen keempat  → index 3

Misalnya:

val names = arrayOf(
    "Ali",
    "Bob",
    "Charlie",
    "David"
)

Maka:

Index       Value
  0         Ali
  1         Bob
  2         Charlie
  3         David

Untuk mengambil "Ali":

println(names[0])

Hasil:

Ali

Untuk mengambil "Charlie":

println(names[2])

Hasil:

Charlie

6. Kenapa index dimulai dari 0?

Ini merupakan konsep umum dalam banyak bahasa pemrograman.

Jadi jangan berpikir:

“Data pertama berarti index 1.”

Dalam programming, biasanya:

Data pertama = index 0.

Misalnya array memiliki 6 elemen:

Index:
0
1
2
3
4
5

Jadi index terakhir adalah:

jumlah elemen - 1

Kalau ada 6 elemen:

6 - 1 = 5

Maka index terakhir adalah 5.

7. Membuat Array dengan arrayOf()

Cara paling mudah membuat Array adalah menggunakan:

arrayOf()

Contoh:

val oddNumbers = arrayOf(1, 3, 5, 7, 9)

Kotlin otomatis mengetahui tipe datanya.

Karena:

1 → Int
3 → Int
5 → Int
7 → Int
9 → Int

Maka Kotlin menyimpulkan:

Array<Int>

Kita tidak harus menulis tipe secara manual.

8. Bisa juga menuliskan tipe secara eksplisit

Misalnya:

val oddNumbers: Array<Int> = arrayOf(1, 3, 5, 7, 9)

Di sini kita secara eksplisit mengatakan:

“oddNumbers adalah Array yang hanya boleh berisi Int.”

Tetapi biasanya Kotlin sudah bisa melakukan type inference, sehingga cukup:

val oddNumbers = arrayOf(1, 3, 5, 7, 9)

Lebih sederhana.

9. Apa maksud Array<Int>?

Ini berkaitan dengan generic.

Untuk sekarang tidak perlu terlalu takut dengan istilah generic.

Cukup pahami bentuknya:

Array<Int>

dibaca:

Array yang berisi Int.

Sedangkan:

Array<String>

berarti:

Array yang berisi String.

Contoh:

val numbers: Array<Int>

berarti:

Array → wadah
<Int> → tipe data yang disimpan

Sedangkan:

val names: Array<String>

berarti:

Array → wadah
<String> → tipe data yang disimpan

10. Mengakses data dalam Array

Misalnya:

val names = arrayOf("Ali", "Bob", "Charlie")

Kita bisa mengambil data menggunakan index:

println(names[0])

Hasil:

Ali

Kemudian:

println(names[1])

Hasil:

Bob

Dan:

println(names[2])

Hasil:

Charlie

Jadi bentuk umumnya:

array[index]

Contoh:

names[1]

artinya:

Ambil elemen pada index 1.

11. Array berguna ketika urutan data penting

Kapan Array berguna?

Misalnya kita mempunyai daftar nilai:

val scores = arrayOf(80, 90, 75, 88)

Urutannya adalah:

Index 0 → 80
Index 1 → 90
Index 2 → 75
Index 3 → 88

Kalau kita tahu index-nya, kita bisa langsung mengambil data tersebut.

Misalnya:

println(scores[2])

hasil:

75

Kita tidak perlu mencari dari awal satu per satu.

12. Membuat Array dengan ukuran tertentu

Selain arrayOf(), Kotlin juga memungkinkan kita membuat array berdasarkan jumlah elemen.

Misalnya kita membutuhkan array dengan 6 elemen:

val sixes = Array(6) { 6 }

Hasilnya secara konsep:

[6, 6, 6, 6, 6, 6]

Mari kita pecah:

Array(6) { 6 }

Bagian:

6

berarti:

Buat array dengan 6 elemen.

Sedangkan:

{ 6 }

menentukan nilai yang akan diberikan kepada setiap elemen.

Jadi:

Array(6) { 6 }

        ↓

6 elemen
        ↓
[6, 6, 6, 6, 6, 6]

Bagian { 6 } ini sebenarnya merupakan lambda, yang akan dipelajari lebih lanjut nanti.

13. Contoh yang lebih menarik

Misalnya kita ingin membuat array berisi:

0
1
2
3
4

Kita bisa menggunakan index:

val numbers = Array(5) { it }

Hasilnya:

[0, 1, 2, 3, 4]

it pada lambda tersebut mewakili index saat elemen dibuat.

Contoh lain:

val numbers = Array(5) { it * 2 }

Hasil:

[0, 2, 4, 6, 8]

Untuk bagian { it } dan { it * 2 }, jangan khawatir dulu. Itu masuk ke materi lambda.

14. val pada Array

Ada hal penting tentang val.

Misalnya:

val vowels = arrayOf("a", "e", "i", "o", "u")

val berarti variabel vowels tidak boleh diarahkan ke array lain.

Misalnya ini tidak boleh:

vowels = arrayOf("x", "y", "z")

Karena vowels adalah val.

Tetapi ada perbedaan penting:

val tidak selalu berarti isi Array tidak boleh berubah.

Contohnya:

val vowels = arrayOf("a", "e", "i", "o", "u")

Kita masih bisa mengubah elemen:

vowels[0] = "A"

Sekarang array menjadi:

[A, e, i, o, u]

Jadi:

val
 ↓
referensi variabel tidak bisa diarahkan ke array lain

bukan:

val
 ↓
seluruh isi array otomatis immutable

Ini perbedaan yang penting.

15. Array<Int> vs IntArray

Nah, bagian ini agak lebih teknis.

Dalam Kotlin ada:

Array<Int>

dan ada:

IntArray

Keduanya sama-sama dapat menyimpan bilangan integer, tetapi cara mereka direpresentasikan di JVM berbeda.

Contoh:

val numbers = arrayOf(1, 2, 3, 4)

Secara tipe:

Array<Int>

Sedangkan:

val numbers = intArrayOf(1, 2, 3, 4)

tipenya:

IntArray

16. Kenapa ada IntArray?

Kotlin berjalan di atas beberapa platform. Salah satunya adalah JVM (Java Virtual Machine).

Java memiliki primitive type seperti:

int
double
float
boolean

Primitive type biasanya lebih efisien dalam penggunaan memory dan performa dibanding object wrapper.

Sedangkan:

Array<Int>

pada JVM berhubungan dengan Integer sebagai object/wrapper.

Secara sederhana:

Array<Int>
     ↓
Integer objects

sedangkan:

IntArray
     ↓
primitive int[]

17. Apa itu Boxing?

Ini yang dimaksud transcript dengan boxing.

Bayangkan kita memiliki primitive:

int

Kemudian primitive tersebut perlu dibungkus menjadi object:

Integer

Proses tersebut disebut:

Boxing

Secara sederhana:

int
 ↓
dibungkus
 ↓
Integer object

Sedangkan kebalikannya disebut:

Unboxing

Integer object
 ↓
dibuka
 ↓
int

Tidak perlu menghafalkan mekanismenya dulu. Yang penting pahami:

Boxing berarti primitive value diperlakukan/dibungkus sebagai object.

18. Kenapa IntArray bisa lebih efisien?

Misalnya kita punya:

val numbers = intArrayOf(1, 2, 3, 4, 5)

Pada JVM, ini bisa direpresentasikan sebagai primitive int[].

Sedangkan:

val numbers = arrayOf(1, 2, 3, 4, 5)

adalah:

Array<Int>

yang melibatkan object/wrapper pada JVM.

Secara umum:

IntArray
→ primitive
→ lebih hemat memory
→ biasanya lebih efisien

Array<Int>
→ object/wrapper
→ bisa memiliki overhead tambahan

Untuk sebagian besar program biasa, perbedaannya mungkin tidak perlu terlalu dipikirkan. Tetapi untuk aplikasi yang melakukan pemrosesan data dalam jumlah besar, hal ini bisa menjadi penting.

19. Cara membuat primitive arrays

Kotlin menyediakan function khusus.

Untuk integer:

intArrayOf()

Contoh:

val evenNumbers = intArrayOf(2, 4, 6, 8)

Tipe:

IntArray

Untuk Double:

doubleArrayOf(1.2, 2.3, 3.4)

Untuk Float:

floatArrayOf(1.2f, 2.3f)

Untuk Boolean:

booleanArrayOf(true, false, true)

Ada juga:

byteArrayOf()
shortArrayOf()
longArrayOf()
charArrayOf()

Jadi kira-kira:

20. Contoh perbandingan

Menggunakan arrayOf()

val numbers = arrayOf(2, 4, 6, 8)

Tipe:

Array<Int>

Menggunakan intArrayOf()

val numbers = intArrayOf(2, 4, 6, 8)

Tipe:

IntArray

Keduanya menyimpan:

2
4
6
8

Tetapi representasi internalnya berbeda.

21. Kenapa transcript mengatakan Array itu “contiguous memory”?

Transcript mengatakan array menyimpan beberapa nilai dalam bagian memory yang berdekatan.

Secara konsep sederhana:

Memory

┌─────┬─────┬─────┬─────┬─────┐
│ 10  │ 20  │ 30  │ 40  │ 50  │
└─────┴─────┴─────┴─────┴─────┘
   0     1     2     3     4

Karena elemen mempunyai posisi/index yang teratur, kita dapat mengakses elemen berdasarkan index.

Misalnya:

numbers[3]

berarti mengambil elemen pada posisi index 3.

Detail implementasi memory ini lebih merupakan konsep di balik Array; sebagai pemula, yang paling penting adalah memahami bahwa Array dirancang untuk menyimpan sekumpulan elemen yang terurut dan dapat diakses berdasarkan index.

22. Satu hal penting: Array bukan List

Jangan sampai nanti bingung ketika masuk ke List.

Array:

val numbers = arrayOf(1, 2, 3)

List:

val numbers = listOf(1, 2, 3)

Keduanya sama-sama menyimpan banyak data, tetapi Array dan List adalah tipe collection yang berbeda dan memiliki karakteristik/API yang berbeda.

Misalnya, salah satu perbedaan penting:

Ukuran Array pada dasarnya ditentukan ketika Array dibuat.

Misalnya:

val numbers = arrayOf(1, 2, 3)

Array tersebut mempunyai 3 elemen.

Kita bisa mengganti isi:

numbers[0] = 100

tetapi bukan berarti Array otomatis menjadi:

[100, 2, 3, 4, 5]

Kalau kita membutuhkan collection yang lebih fleksibel dalam menambah/menghapus elemen, nanti List/MutableList akan lebih relevan.

23. Gambaran besar materi ini

Supaya tidak bingung dengan banyak istilah, pahami hierarkinya seperti ini:

Collection
│
├── Array
│
├── List
│
├── Set
│
└── Map

Sekarang kita sedang belajar:

Collection
    │
    └── Array

Dan di dalam Array ada dua konsep yang perlu kamu kenali:

Array<T>
│
├── Array<String>
├── Array<Int>
└── dll.

serta primitive arrays:

IntArray
DoubleArray
FloatArray
BooleanArray
CharArray
...

24. Contoh lengkap

Misalnya kita ingin membuat daftar nama:

val names = arrayOf(
    "Ali",
    "Budi",
    "Citra",
    "Doni"
)

Kita bisa mengambil nama:

println(names[0])

Output:

Ali

println(names[2])

Output:

Citra

Kita juga bisa mengubah elemen:

names[1] = "Andi"

Sekarang:

Index    Value
  0      Ali
  1      Andi
  2      Citra
  3      Doni

25. Kesalahan yang sering dilakukan pemula

Kesalahan 1 — Mengira index dimulai dari 1

❌ Salah:

names[1] // mengira nama pertama

Padahal:

names[0]

adalah nama pertama.

Kesalahan 2 — Memasukkan tipe berbeda

val numbers = arrayOf(1, 2, 3)

Kemudian:

numbers[0] = "Hello"

❌ Tidak boleh karena array tersebut adalah Array<Int>.

Kesalahan 3 — Mengira val membuat isi Array tidak bisa berubah

val numbers = arrayOf(1, 2, 3)

numbers[0] = 100

Ini masih boleh.

Yang tidak boleh:

numbers = arrayOf(4, 5, 6)

Karena numbers adalah val.

Kesalahan 4 — Bingung Array<Int> dengan IntArray

arrayOf(1, 2, 3)

→ Array<Int>

Sedangkan:

intArrayOf(1, 2, 3)

→ IntArray

Keduanya bukan tipe yang sama.

26. Cara mengingat semuanya

Gunakan pola sederhana ini:

arrayOf()

“Buat Array biasa.”

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

Hasil:

Array<String>

intArrayOf()

“Buat Array khusus primitive Int.”

val numbers = intArrayOf(10, 20, 30)

Hasil:

IntArray

Array(size) { ... }

“Buat Array dengan jumlah elemen tertentu dan tentukan nilai tiap elemen.”

val numbers = Array(5) { 0 }

Hasil:

[0, 0, 0, 0, 0]

27. Ringkasan paling penting

Kalau materi ini terasa panjang, minimal kuasai 8 hal berikut:

1. Array adalah kumpulan beberapa nilai.

2. Elemen Array memiliki tipe yang sama.

Array<String>
Array<Int>

3. Index dimulai dari 0.

0 → elemen pertama
1 → elemen kedua
2 → elemen ketiga

4. Elemen diakses menggunakan index.

names[0]

5. Cara sederhana membuat Array:

arrayOf(1, 2, 3)

6. Array<Int> dan IntArray berbeda.

arrayOf(1, 2, 3)     // Array<Int>
intArrayOf(1, 2, 3)  // IntArray

7. IntArray menggunakan representasi primitive pada JVM dan umumnya lebih efisien daripada Array<Int> untuk data integer.

8. Array(6) { 6 } berarti membuat Array berisi 6 elemen, masing-masing diinisialisasi dengan nilai 6.

Jadi kalau disederhanakan menjadi satu kalimat:

Array di Kotlin adalah wadah terurut untuk menyimpan banyak nilai dengan tipe yang sama, setiap nilai punya index mulai dari 0, dan Kotlin menyediakan arrayOf() untuk Array umum serta IntArray, DoubleArray, dan sejenisnya untuk primitive arrays.