Bagian ini membahas cara mengecek apakah sebuah elemen ada di dalam Array atau List menggunakan operator in, lalu bagaimana membuat pengecekan tersebut menjadi sebuah function agar bisa digunakan berkali-kali.

Ini konsep yang cukup penting karena nantinya sering sekali dipakai dalam program.

1. Apa yang ingin kita lakukan?

Misalnya kita punya sebuah List berisi nama:

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

Kita ingin bertanya:

“Apakah Jack ada di dalam names?”

Atau:

“Apakah Johnny ada di dalam names?”

Hasil dari pertanyaan tersebut adalah Boolean:

true  → ada
false → tidak ada

2. Menggunakan operator in

Kotlin menyediakan operator:

in

untuk mengecek apakah sebuah elemen terdapat di dalam suatu collection seperti List atau Array.

Bentuk sederhananya:

element in collection

Contoh:

println("Jack" in names)

Kalau Jack ada:

true

Kalau tidak ada:

false

3. Cara membaca in

Misalnya:

"Jack" in names

Bacanya jangan seperti kode yang rumit.

Baca saja:

“Apakah Jack ada di dalam names?”

Atau dalam bahasa sehari-hari:

“Apakah Jack termasuk anggota dari names?”

Hasilnya berupa Boolean.

"Jack" in names
      ↓
   pengecekan
      ↓
   true / false

4. Contoh lengkap

Misalnya:

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

    println("Jack" in names)
}

Karena "Jack" memang ada:

true

Kalau kita ganti menjadi:

println("Johnny" in names)

dan Johnny tidak ada di List, hasilnya:

false

5. in mengembalikan Boolean

Ini sangat penting.

Ekspresi:

"Jack" in names

menghasilkan:

Boolean

yaitu:

true

atau:

false

Karena itu kita bisa langsung memasukkannya ke if.

Contoh:

if ("Jack" in names) {
    println("Jack ditemukan")
}

Kalau Jack ada, program menjalankan:

Jack ditemukan

Kalau tidak ada, blok tersebut tidak dijalankan.

6. in juga bisa digunakan di if

Contoh yang lebih lengkap:

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

if ("Jack" in names) {
    println("Jack ada di dalam list")
} else {
    println("Jack tidak ditemukan")
}

Hasil:

Jack ada di dalam list

Karena kondisi:

"Jack" in names

bernilai:

true

7. Case-sensitive

Ada satu hal penting yang disebutkan dalam video:

Pengecekan String di Kotlin bersifat case-sensitive.

Artinya huruf besar dan huruf kecil dianggap berbeda.

Misalnya:

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

Kemudian:

println("Jack" in names)

hasil:

true

Tetapi:

println("jack" in names)

hasil:

false

Kenapa?

Karena:

"Jack"

berbeda dengan:

"jack"

Huruf:

J

dan:

j

dianggap berbeda.

Begitu juga:

"ALI"
"Ali"
"ali"

semuanya berbeda.

Jadi hati-hati:

"Ali" in names

bisa menghasilkan:

true

sedangkan:

"ali" in names

bisa menghasilkan:

false

tergantung isi List.

8. in bisa digunakan untuk Array juga

Konsepnya tidak hanya untuk List.

Misalnya Array:

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

Kita tetap bisa:

println("Jack" in names)

hasil:

true

Jadi secara sederhana:

List  → bisa menggunakan in
Array → bisa menggunakan in

9. Sekarang masuk ke Function

Sampai sini kita bisa melakukan:

println("Jack" in names)

Tetapi bayangkan program kita semakin besar.

Kita ingin melakukan pengecekan berkali-kali:

Apakah Ali ada?
Apakah Jack ada?
Apakah George ada?
Apakah John ada?
Apakah Budi ada?
...

Kalau kita menulis kode pengecekan terus-menerus, program bisa menjadi berantakan.

Maka lebih baik kita membuat sebuah function.

10. Membuat function isFound

Dalam video dibuat function seperti:

fun isFound(
    name: String,
    namesArray: Array<String>
): Boolean {
    return name in namesArray
}

Mari kita bedah pelan-pelan.

11. Bagian fun isFound

fun isFound

Artinya kita membuat function bernama:

isFound

Nama tersebut cukup bagus karena menggambarkan tujuan function:

“Apakah ditemukan?”

12. Parameter name: String

Bagian:

name: String

berarti function membutuhkan sebuah parameter bernama name.

Tipe datanya:

String

Jadi kita bisa memberikan nama seperti:

"Ali"

atau:

"George"

atau:

"Jack"

Contoh:

isFound("George", ...)

Maka:

name = "George"

13. Parameter kedua: Array

Function juga membutuhkan Array yang akan dicari.

Misalnya:

namesArray: Array<String>

Artinya:

namesArray adalah Array yang berisi String.

Jadi function menerima dua input:

1. name
   → apa yang ingin dicari

2. namesArray
   → di mana kita mencarinya

Visualisasinya:

isFound(
    "George",
    namesArray
)
    ↓
    ↓
    └── tempat pencarian
    └──── yang dicari

14. Kenapa function membutuhkan dua parameter?

Ini konsep yang sangat bagus untuk dipahami.

Function kita bertugas:

Mencari sebuah nama di dalam sebuah Array.

Kalau hanya diberi:

"George"

function tidak tahu harus mencari George di mana.

Sebaliknya kalau hanya diberi:

namesArray

function tidak tahu apa yang harus dicari.

Maka kita butuh dua informasi:

APA yang dicari?
        +
DI MANA mencarinya?

Contohnya:

isFound("George", namesArray)

Artinya:

“Cari George di dalam namesArray.”

15. ): Boolean

Setelah parameter ada:

): Boolean

Ini menunjukkan bahwa function akan mengembalikan nilai:

Boolean

Jadi hasil function hanya bisa:

true

atau:

false

Contohnya:

val result = isFound("George", namesArray)

Maka result akan berisi:

true

atau:

false

16. Bagian return

Isi function:

return name in namesArray

Ini sebenarnya sangat sederhana.

Kita sudah tahu:

name in namesArray

menghasilkan:

true / false

Jadi kita tinggal mengembalikan hasil tersebut.

Misalnya:

name = "George"
namesArray = ["Ali", "Jack", "George"]

Maka:

name in namesArray

menjadi:

"George" in namesArray

Hasil:

true

Kemudian:

return true

Function selesai.

17. Alur function secara keseluruhan

Perhatikan alurnya:

isFound("George", namesArray)
             │
             ▼
       name = "George"
             │
             ▼
     name in namesArray
             │
        ┌────┴────┐
        ▼         ▼
      ketemu    tidak
        │         │
        ▼         ▼
      true      false

Jadi function ini sebenarnya hanya membungkus pengecekan:

name in namesArray

supaya bisa digunakan berulang kali.

18. Contoh lengkap dengan Array

Misalnya:

fun isFound(
    name: String,
    namesArray: Array<String>
): Boolean {
    return name in namesArray
}

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

    println(isFound("George", names))
    println(isFound("Johnny", names))
}

Hasil:

true
false

Kenapa?

Pertama:

isFound("George", names)

George ada:

true

Kedua:

isFound("Johnny", names)

Johnny tidak ada:

false

19. Perhatikan urutan parameter

Function:

fun isFound(
    name: String,
    namesArray: Array<String>
)

memiliki urutan:

parameter pertama → name
parameter kedua   → namesArray

Maka ketika dipanggil:

isFound("George", names)

berarti:

name       = "George"
namesArray = names

Jangan sampai terbalik.

20. Kalau menggunakan MutableList

Caption menunjukkan ada sedikit perubahan dari Array ke MutableList. Ini tidak mengubah konsep dasarnya.

Misalnya:

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

Kita tetap bisa:

println("George" in names)

Hasil:

true

Karena in juga dapat digunakan untuk collection seperti List.

Function-nya bisa disesuaikan menjadi:

fun isFound(
    name: String,
    names: List<String>
): Boolean {
    return name in names
}

Bahkan ini lebih fleksibel karena List<String> bisa menerima List yang read-only maupun mutable.

Contoh:

fun isFound(
    name: String,
    names: List<String>
): Boolean {
    return name in names
}

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

    println(isFound("Ali", names))
}

Output:

true

21. Kenapa function seperti ini berguna?

Bayangkan kita punya banyak tempat yang membutuhkan pengecekan nama.

Daripada menulis:

if ("Ali" in names) {
    ...
}

if ("Jack" in names) {
    ...
}

if ("George" in names) {
    ...
}

kita bisa menggunakan:

isFound("Ali", names)
isFound("Jack", names)
isFound("George", names)

Function menjadi seperti alat yang bisa dipakai berulang kali.

Analoginya:

Function isFound
       │
       ▼
┌───────────────────┐
│    Alat pencari   │
│                   │
│ "Apa yang dicari?"│
│ "Cari di mana?"   │
└─────────┬─────────┘
          │
          ▼
      true / false

22. in sebenarnya sangat nyaman

Tanpa in, kita mungkin harus menggunakan cara yang lebih panjang.

Dengan in, kita cukup:

name in names

yang secara sederhana bisa dibaca:

“Apakah name ada di dalam names?”

Ini membuat kode Kotlin menjadi cukup natural untuk dibaca.

23. Jangan tertukar dengan !in

Ada pasangan dari in, yaitu:

!in

Kalau:

"Ali" in names

artinya:

Ali ada di dalam names.

Sedangkan:

"Ali" !in names

artinya:

Ali tidak ada di dalam names.

Contoh:

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

println("Ali" in names)
println("George" !in names)

Output:

true
true

Karena:

Ali    → ada
George → tidak ada

24. Hubungan in dengan contains()

Ada cara lain yang mungkin nanti kamu temui:

names.contains("Jack")

Ini juga digunakan untuk mengecek apakah elemen ada.

Misalnya:

"Jack" in names

dan:

names.contains("Jack")

secara konsep melakukan pengecekan yang sama.

Untuk sekarang, cukup ingat:

"Jack" in names

adalah bentuk yang sangat nyaman dan mudah dibaca.

25. Kesalahan pemahaman yang sering terjadi

❌ Salah: in mengembalikan elemen

Misalnya:

"Jack" in names

bukan berarti hasilnya:

Jack

Hasilnya adalah:

true

atau:

false

❌ Salah: in mencari berdasarkan index

in tidak berarti:

2 in names

untuk mengambil index 2.

Untuk mengambil berdasarkan index, kita menggunakan:

names[2]

Sedangkan:

"Jack" in names

digunakan untuk mengecek keberadaan elemen.

26. Bedakan [index] dengan in

Ini penting sekali karena keduanya berhubungan dengan List/Array tetapi tujuannya berbeda.

Misalnya:

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

Mengambil elemen:

names[1]

Hasil:

Jack

Pertanyaannya:

“Apa isi index 1?”

Mengecek keberadaan:

"Jack" in names

Hasil:

true

Pertanyaannya:

“Apakah Jack ada di dalam list?”

Jadi:

names[1]
   ↓
AMBIL elemen


"Jack" in names
       ↓
CEK apakah elemen ada

27. Ringkasan konsep

Kita sekarang sudah belajar beberapa cara mengakses dan mengecek Array/List:

🧠 Cara mengingat paling gampang

Bayangkan kamu punya daftar peserta:

names
   ↓
["Ali", "Jack", "George", "John"]
   0      1        2        3

Kalau bertanya:

“Siapa yang berada di posisi 1?”

Gunakan:

names[1]

→ Jack

Kalau bertanya:

“Siapa orang pertama?”

Gunakan:

names.first()

→ Ali

Kalau bertanya:

“Siapa orang terakhir?”

Gunakan:

names.last()

→ John

Kalau bertanya:

“Apakah Jack ada?”

Gunakan:

"Jack" in names

→ true

Kalau bertanya:

“Apakah Budi tidak ada?”

Gunakan:

"Budi" !in names

→ true

Kalau ingin membuat alat pengecekan yang bisa digunakan berkali-kali:

fun isFound(
    name: String,
    names: List<String>
): Boolean {
    return name in names
}

Lalu:

isFound("Jack", names)

→ true

isFound("Budi", names)

→ false

🔑 Inti materi ini

[index] = ambil elemen berdasarkan posisi.

in = cek apakah elemen ada.

!in = cek apakah elemen tidak ada.

isFound() = kita bisa membungkus pengecekan tersebut ke dalam function agar dapat digunakan berkali-kali.

Dan jangan lupa: String bersifat case-sensitive, sehingga "Jack" dan "jack" dianggap berbeda.