Menggunakan koleksi di Kotlin

1. Pengantar

Di banyak aplikasi, Anda mungkin telah melihat data ditampilkan sebagai daftar: kontak, setelan, hasil penelusuran, dll.

9fbd3bf7cb6adc72.png

Namun, dalam kode yang telah Anda tulis sejauh ini, Anda paling sering menangani data yang terdiri dari satu nilai, seperti angka atau potongan teks yang ditampilkan di layar. Untuk mem-build aplikasi yang melibatkan jumlah data arbitrer, Anda perlu mempelajari cara menggunakan koleksi.

Jenis koleksi (terkadang disebut struktur data) memungkinkan Anda menyimpan beberapa nilai, biasanya dengan jenis data yang sama, dengan cara yang teratur. Koleksi mungkin berupa daftar yang diurutkan, pengelompokan nilai unik, atau pemetaan nilai dari satu jenis data ke nilai yang lain. Kemampuan untuk menggunakan koleksi secara efektif memungkinkan Anda menerapkan fitur umum aplikasi Android, seperti daftar scroll, serta memecahkan berbagai masalah pemrograman nyata yang melibatkan jumlah data arbitrer.

Codelab ini membahas cara menangani beberapa nilai dalam kode Anda, dan memperkenalkan berbagai struktur data, termasuk array, daftar, set, dan peta.

Prasyarat

  • Pemahaman tentang pemrograman berorientasi objek di Kotlin, termasuk class, antarmuka, dan generik.

Yang akan Anda pelajari

  • Cara membuat dan mengubah array.
  • Cara menggunakan List dan MutableList.
  • Cara menggunakan Set dan MutableSet.
  • Cara menggunakan Map dan MutableMap.

Yang Anda butuhkan

  • Browser web dengan akses ke Kotlin Playground.

2. Array di Kotlin

Apa yang dimaksud dengan array?

Array adalah cara paling sederhana untuk mengelompokkan jumlah nilai arbitrer dalam program Anda.

Seperti pengelompokan panel surya yang disebut array surya, atau bagaimana pembelajaran Kotlin membuka array kemungkinan untuk karier pemrograman Anda, Array merepresentasikanlebih dari satu nilai. Secara khusus, array adalah urutan nilai yang semuanya memiliki jenis data yang sama.

960e34f4c96e2fd9.png

  • Array berisi beberapa nilai yang disebut elemen, atau terkadang item.
  • Elemen dalam array diurutkan dan diakses dengan indeks.

Apa itu indeks? Indeks adalah bilangan bulat yang sesuai dengan elemen dalam array. Indeks memberi tahu jarak item dari elemen awal dalam array. Hal ini disebut pengindeksan nol. Elemen pertama array ada pada indeks 0, elemen kedua ada pada indeks 1, karena merupakan satu tempat dari elemen pertama, dan seterusnya.

5baf880a3670720d.png

Dalam memori perangkat, elemen dalam array disimpan bersebelahan. Meskipun detail yang mendasari berada di luar cakupan codelab ini, hal ini memiliki dua implikasi penting:

  • Akses elemen array oleh indeksnya berlangsung cepat. Anda dapat mengakses elemen acak dari suatu array menurut indeksnya dan memperkirakan bahwa akan diperlukan waktu yang sama untuk mengakses elemen acak lainnya. Disebutkan bahwa array tersebut memiliki akses acak.
  • Array memiliki ukuran tetap. Ini berarti Anda tidak dapat menambahkan elemen ke array di luar ukuran ini. Mencoba mengakses elemen pada indeks 100 dalam array elemen 100 akan menampilkan pengecualian karena indeks tertinggi adalah 99 (ingat bahwa indeks pertama adalah 0, bukan 1). Namun, Anda dapat mengubah nilai pada indeks di array.

Untuk mendeklarasikan array dalam kode, gunakan fungsi arrayOf().

9d5c8c00b30850cb.png

Fungsi arrayOf() menggunakan elemen array sebagai parameter, dan menampilkan array jenis yang cocok dengan parameter yang diteruskan. Fungsi ini mungkin terlihat sedikit berbeda dari fungsi lain yang telah Anda lihat karena arrayOf() memiliki jumlah parameter yang bervariasi. Jika Anda meneruskan dua argumen ke arrayOf(), array yang dihasilkan berisi dua elemen, yang diindeks 0 dan 1. Jika Anda meneruskan tiga argumen, array yang dihasilkan akan memiliki 3 elemen, yang diindeks 0 sampai 2.

Mari kita lihat aksi array dengan eksplorasi kecil pada tata surya.

  1. Buka Kotlin Playground.
  2. Di main(), buat variabel rockPlanets. Panggil arrayOf(), yang meneruskan jenis String, bersama dengan empat string—satu untuk setiap planet batu dalam tata surya.
val rockPlanets = arrayOf<String>("Mercury", "Venus", "Earth", "Mars")
  1. Karena Kotlin menggunakan inferensi jenis, Anda dapat menghilangkan nama jenis saat memanggil arrayOf(). Di bawah variabel rockPlanets, tambahkan variabel lain gasPlanets, tanpa meneruskan jenis ke dalam tanda kurung sudut.
val gasPlanets = arrayOf("Jupiter", "Saturn", "Uranus", "Neptune")
  1. Anda dapat melakukan beberapa hal hebat dengan array. Misalnya, seperti jenis numerik Int atau Double, Anda dapat menambahkan dua array secara bersamaan. Buat variabel baru bernama solarSystem, dan tetapkan sama dengan hasil rockPlanets dan gasPlanets, menggunakan operator plus (+). Hasilnya adalah array baru yang berisi semua elemen array rockPlanets dan elemen array gasPlanets.
val solarSystem = rockPlanets + gasPlanets
  1. Jalankan program Anda untuk memverifikasi bahwa program ini berfungsi. Anda seharusnya tidak melihat output apa pun.

Mengakses elemen dalam array

Anda dapat mengakses elemen array melalui indeksnya.

1f8398eaee30c7b0.png

Ini disebut sintaksis subskrip. Sintaksis ini terdiri dari tiga bagian:

  • Nama array.
  • Tanda kurung siku buka ([) dan tutup (]).
  • Indeks elemen array dalam tanda kurung siku.

Mari kita akses elemen array solarSystem berdasarkan indeksnya.

  1. Di main(), akses dan cetak setiap elemen array solarSystem. Perhatikan bagaimana indeks pertama adalah 0 dan indeks terakhir adalah 7.
println(solarSystem[0])
println(solarSystem[1])
println(solarSystem[2])
println(solarSystem[3])
println(solarSystem[4])
println(solarSystem[5])
println(solarSystem[6])
println(solarSystem[7])
  1. Jalankan program Anda. Elemen berada dalam urutan yang sama dengan yang Anda cantumkan saat memanggil arrayOf().
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Anda juga dapat menetapkan nilai elemen array berdasarkan indeksnya.

9469e321ed79c074.png

Mengakses indeks sama seperti sebelumnya—nama array, diikuti oleh tanda kurung siku buka dan tutup yang berisi indeks. Kemudian diikuti oleh operator penugasan (=) dan nilai baru.

Mari berlatih mengubah nilai pada array solarSystem.

  1. Mari beri nama baru untuk Mars bagi para pemukim manusia di masa depan. Akses elemen pada indeks 3 dan tetapkan sama dengan "Little Earth".
solarSystem[3] = "Little Earth"
  1. Cetak elemen pada indeks 3.
println(solarSystem[3])
  1. Jalankan program Anda. Elemen keempat array (pada indeks 3) telah diupdate.
...
Little Earth
  1. Sekarang, anggap para ilmuwan menemukan bahwa ada planet kesembilan di luar Neptunus yang bernama Pluto. Sebelumnya, kami menyebutkan bahwa Anda tidak dapat mengubah ukuran array. Apa yang akan terjadi jika Anda mencoba? Mari coba tambahkan Pluto ke array solarSystem. Tambahkan Pluto pada indeks 8 karena ini adalah elemen ke-9 dalam array.
solarSystem[8] = "Pluto"
  1. Jalankan kode. Pengecualian ArrayIndexOutOfBounds akan ditampilkan. Karena array sudah memiliki 8 elemen, seperti yang diharapkan, Anda tidak dapat langsung menambahkan elemen kesembilan.
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 8 out of bounds for length 8
  1. Hapus penambahan Pluto ke array.

Kode yang akan dihapus

solarSystem[8] = "Pluto"
  1. Jika ingin membuat array lebih besar dari yang sudah ada, Anda harus membuat array baru. Tentukan variabel baru bernama newSolarSystem seperti yang ditunjukkan. Array ini dapat menyimpan sembilan elemen, bukan delapan.
val newSolarSystem = arrayOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto")
  1. Sekarang coba cetak elemen pada indeks 8.
println(newSolarSystem[8])
  1. Jalankan kode Anda dan amati bahwa kode berjalan tanpa pengecualian.
...
Pluto

Bagus. Dengan pengetahuan Anda tentang array, Anda dapat melakukan hampir semua hal dengan koleksi.

Namun, tidak semudah itu. Meskipun array adalah salah satu aspek dasar pemrograman, menggunakan array untuk tugas yang memerlukan penambahan dan penghapusan elemen, keunikan dalam koleksi, atau pemetaan objek ke objek lain tidak sederhana atau mudah, dan kode aplikasi Anda akan dengan cepat menjadi berantakan.

Oleh karena itu, sebagian besar bahasa pemrograman, termasuk Kotlin, mengimplementasikan jenis koleksi khusus untuk menangani situasi yang umum terjadi di aplikasi dunia nyata. Di bagian berikut, Anda akan mempelajari tiga koleksi umum: List, Set, dan Map. Anda juga akan mempelajari properti dan metode umum, serta situasi yang tepat untuk menggunakan jenis koleksi ini.

3. Daftar

Daftar adalah koleksi yang diurutkan dan dapat diubah ukurannya, biasanya diterapkan sebagai array yang dapat diubah ukurannya. Saat array diisi sesuai kapasitas dan Anda mencoba menyisipkan elemen baru, array tersebut akan disalin ke array baru yang lebih besar.

a4970d42cd1d2b66.png

Dengan daftar, Anda juga dapat menyisipkan elemen baru di antara elemen lainnya pada indeks tertentu.

27afd8dd880e1ae5.png

Ini adalah cara daftar dapat menambahkan dan menghapus elemen. Pada umumnya, diperlukan waktu yang sama untuk menambahkan elemen apa pun ke dalam daftar, terlepas dari berapa banyak elemen yang ada dalam daftar. Terkadang, jika menambahkan elemen baru akan menempatkan array di atas ukuran yang ditentukan, elemen array mungkin harus dipindahkan untuk menyediakan ruang bagi elemen baru. Daftar melakukan semua ini untuk Anda, tetapi di balik layar, daftar hanyalah array yang ditukar dengan array baru saat diperlukan.

List dan MutableList

Jenis koleksi yang akan Anda temui di Kotlin mengimplementasikan satu atau beberapa antarmuka. Seperti yang telah Anda pelajari di codelab Generik, Objek, dan Ekstensi sebelumnya di unit ini, antarmuka memberikan kumpulan properti dan metode standar untuk diterapkan oleh class. Class yang mengimplementasikan antarmuka List menyediakan implementasi untuk semua properti dan metode antarmuka List. Hal yang sama berlaku untuk MutableList.

Jadi, apa fungsi List dan MutableList?

  • List adalah antarmuka yang menentukan properti dan metode terkait koleksi item baca-saja yang diurutkan.
  • MutableList memperluas antarmuka List dengan menentukan metode untuk mengubah daftar, seperti menambahkan dan menghapus elemen.

Antarmuka ini hanya menentukan properti dan metode List dan/atau MutableList. Penentuan cara setiap properti dan metode diimplementasikan bergantung pada class yang memperluasnya. Implementasi berbasis array yang dijelaskan di atas adalah yang paling sering Anda gunakan, jika tidak selalu, tetapi Kotlin memungkinkan class lain untuk memperluas List dan MutableList.

Fungsi listOf()

Seperti arrayOf(), fungsi listOf() mengambil item sebagai parameter, tetapi menampilkan List, bukan array.

  1. Hapus kode yang ada dari main().
  2. Dalam main(), buat List planet yang bernama solarSystem dengan memanggil listOf().
fun main() {
    val solarSystem = listOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
}
  1. List memiliki properti size untuk mendapatkan jumlah elemen dalam daftar. Cetak size dari daftar solarSystem.
println(solarSystem.size)
  1. Jalankan kode. Ukuran daftar seharusnya 8.
8

Mengakses elemen dari daftar

Seperti array, Anda dapat mengakses elemen pada indeks tertentu dari List menggunakan sintaksis subskrip. Anda dapat melakukan hal yang sama menggunakan metode get(). Sintaksis subskrip dan metode get() menggunakan Int sebagai parameter dan menampilkan elemen pada indeks tersebut. Seperti Array, ArrayList diindeks nol, jadi misalnya, elemen keempat akan berada di indeks 3.

  1. Cetak planet pada indeks 2 menggunakan sintaksis subskrip.
println(solarSystem[2])
  1. Cetak elemen pada indeks 3 dengan memanggil get() pada daftar solarSystem.
println(solarSystem.get(3))
  1. Jalankan kode. Elemen pada indeks 2 adalah "Earth" dan elemen pada indeks 3 adalah "Mars".
...
Earth
Mars

Selain mendapatkan elemen berdasarkan indeksnya, Anda juga dapat menelusuri indeks elemen tertentu menggunakan metode indexOf(). Metode indexOf() menelusuri daftar untuk elemen tertentu (diteruskan sebagai argumen), dan menampilkan indeks kejadian pertama dari elemen tersebut. Jika tidak muncul dalam daftar, elemen akan menampilkan -1.

  1. Cetak hasil panggilan indexOf() di daftar solarSystem, yang meneruskan "Earth".
println(solarSystem.indexOf("Earth"))
  1. Panggil indexOf(), yang meneruskan "Pluto", dan cetak hasilnya.
println(solarSystem.indexOf("Pluto"))
  1. Jalankan kode. Elemen cocok dengan "Earth", sehingga indeksnya, 2, akan dicetak. Tidak ada elemen yang cocok dengan "Pluto", sehingga -1 akan dicetak.
...
2
-1

Lakukan iterasi pada elemen daftar menggunakan loop for

Saat mempelajari jenis fungsi dan ekspresi lambda, Anda telah melihat cara menggunakan fungsi repeat() untuk mengeksekusi kode beberapa kali.

Tugas umum dalam pemrograman adalah melakukan tugas satu kali untuk setiap elemen dalam daftar. Kotlin menyertakan fitur yang disebut loop for untuk melakukannya dengan sintaksis yang ringkas dan dapat dibaca. Anda akan sering melihat hal ini disebut sebagai looping melalui daftar atau iterasi melalui daftar.

1245a226a9ceeba1.png

Untuk melakukan loop pada daftar, gunakan kata kunci for, yang diikuti dengan sepasang tanda kurung buka dan tutup. Dalam tanda kurung, sertakan nama variabel, diikuti dengan kata kunci in, diikuti dengan nama koleksi. Setelah tanda kurung tutup, sepasang tanda kurung kurawal buka dan tutup akan ditampilkan, tempat Anda menyertakan kode yang ingin dieksekusi untuk setiap elemen dalam koleksi. Ini dikenal sebagai isi loop. Setiap eksekusi kode ini dikenal sebagai iterasi.

Variabel sebelum kata kunci in tidak dideklarasikan dengan val atau var, sehingga diasumsikan sebagai dapatkan-saja. Anda dapat memberinya nama apa pun. Jika daftar diberi nama jamak, seperti planets, nama variabel biasanya dalam bentuk tunggal, seperti planet. Nama variabel item atau element juga umum digunakan.

Nama ini akan digunakan sebagai variabel sementara yang sesuai dengan elemen saat ini dalam koleksi—elemen pada indeks 0 untuk iterasi pertama, elemen pada indeks 1 untuk iterasi kedua, dan seterusnya, serta dapat diakses dalam kurung kurawal.

Untuk melihat cara kerjanya, Anda akan mencetak setiap nama planet di baris yang terpisah menggunakan loop for.

  1. Di main(), di bawah panggilan terbaru ke println(), tambahkan loop for. Dalam tanda kurung, beri nama variabel planet, dan lakukan loop melalui daftar solarSystem.
for (planet in solarSystem) {
}
  1. Dalam tanda kurung kurawal, cetak nilai planet menggunakan println().
for (planet in solarSystem) {
    println(planet)
}
  1. Jalankan kode. Kode dalam isi loop dieksekusi untuk setiap item dalam koleksi.
...
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

Menambahkan elemen ke daftar

Kemampuan untuk menambahkan, menghapus, dan mengupdate elemen dalam suatu koleksi bersifat eksklusif untuk class yang mengimplementasikan antarmuka MutableList. Jika melacak planet yang baru ditemukan, Anda mungkin menginginkan kemampuan untuk sering menambahkan elemen ke daftar. Anda harus secara khusus memanggil fungsi mutableListOf(), bukan listOf(), saat membuat daftar yang ingin Anda tambahkan dan hapus elemennya.

Ada dua versi fungsi add():

  • Fungsi add() pertama memiliki satu parameter jenis elemen dalam daftar dan menambahkannya ke akhir daftar.
  • Versi lain dari add() memiliki dua parameter. Parameter pertama sesuai dengan indeks tempat elemen baru harus dimasukkan. Parameter kedua adalah elemen yang ditambahkan ke daftar.

Mari kita lihat penerapan keduanya.

  1. Ubah inisialisasi solarSystem agar memanggil mutableListOf(), bukan listOf(). Sekarang Anda dapat memanggil metode yang ditentukan di MutableList.
val solarSystem = mutableListOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
  1. Sekali lagi, kita mungkin ingin mengklasifikasikan Pluto sebagai planet. Panggil metode add() di solarSystem, dengan meneruskan "Pluto" sebagai argumen tunggal.
solarSystem.add("Pluto")
  1. Beberapa ilmuwan memiliki teori bahwa dahulu ada planet bernama Theia sebelum menabrak Bumi dan membentuk Bulan. Sisipkan "Theia" pada indeks 3, antara "Earth" dan "Mars".
solarSystem.add(3, "Theia")

Mengupdate elemen pada indeks tertentu

Anda dapat mengupdate elemen yang ada dengan sintaksis subskrip:

  1. Update nilai pada indeks 3 menjadi "Future Moon".
solarSystem[3] = "Future Moon"
  1. Cetak nilai pada indeks 3 dan 9 menggunakan sintaksis subskrip.
println(solarSystem[3])
println(solarSystem[9])
  1. Jalankan kode untuk memverifikasi output.
Future Moon
Pluto

Menghapus elemen dari daftar

Elemen dihapus menggunakan metode remove() atau removeAt(). Anda dapat menghapus elemen dengan meneruskannya ke metode remove() atau dengan indeksnya menggunakan removeAt().

Mari kita lihat kedua metode untuk menghapus elemen yang sedang bekerja.

  1. Panggil removeAt() pada solarSystem, yang meneruskan 9 untuk indeks. Tindakan ini akan menghapus "Pluto" dari daftar.
solarSystem.removeAt(9)
  1. Panggil remove() pada solarSystem, yang meneruskan "Future Moon" sebagai elemen yang akan dihapus. Tindakan ini akan menelusuri daftar, dan jika ditemukan elemen yang cocok, elemen tersebut akan dihapus.
solarSystem.remove("Future Moon")
  1. List menyediakan metode contains() yang menampilkan Boolean jika elemen ada dalam daftar. Cetak hasil panggilan contains() untuk "Pluto".
println(solarSystem.contains("Pluto"))
  1. Untuk sintaksis yang lebih ringkas, Anda dapat menggunakan operator in. Anda dapat memeriksa apakah suatu elemen berada dalam daftar menggunakan elemen, operator in, dan koleksi. Gunakan operator in untuk memeriksa apakah solarSystem berisi "Future Moon".
println("Future Moon" in solarSystem)
  1. Jalankan kode. Kedua pernyataan harus mencetak false.
...
false
false

4. Set

Set adalah koleksi yang tidak memiliki urutan tertentu dan tidak mengizinkan nilai duplikat.

ce127adf37662aa4.png

Bagaimana koleksi bisa seperti ini? Rahasianya adalah kode hash. Kode hash adalah Int yang dihasilkan oleh metode hashCode() dari class Kotlin mana pun. Kode ini dapat dianggap sebagai ID semi-unik untuk objek Kotlin. Perubahan kecil pada objek, seperti menambahkan satu karakter ke String, akan menghasilkan nilai hash yang sangat berbeda. Meskipun dua objek dapat memiliki kode hash yang sama (disebut tumpang tindih hash), fungsi hashCode() memastikan adanya tingkat keunikan yang membuat dua nilai berbeda hampir selalu memiliki kode hash unik masing-masing.

84842b78e78f2f58.png

Set memiliki dua properti penting:

  1. Menelusuri elemen tertentu dalam suatu set dapat dilakukan dengan cepat—dibandingkan dengan daftar—terutama untuk koleksi besar. Meskipun indexOf() dari List memerlukan pemeriksaan setiap elemen dari awal hingga kecocokan ditemukan, rata-rata diperlukan waktu yang sama untuk memeriksa apakah elemen berada dalam set atau tidak, apakah itu elemen pertama atau yang keseratus ribu.
  2. Set cenderung menggunakan lebih banyak memori daripada daftar untuk jumlah data yang sama, karena indeks array lebih sering diperlukan dibandingkan dengan data dalam set.

Manfaat set adalah memastikan keunikan. Jika Anda menulis program untuk melacak planet yang baru ditemukan, set menyediakan cara mudah untuk memeriksa apakah planet telah ditemukan. Dengan data dalam jumlah besar, biasanya lebih disarankan untuk memeriksa apakah elemen ada dalam daftar, yang mengharuskan iterasi pada semua elemen.

Seperti List dan MutableList, ada Set dan MutableSet. MutableSet mengimplementasikan Set, sehingga class apa pun yang mengimplementasikan MutableSet harus mengimplementasikan keduanya.

691f995fde47f1ff.png

Menggunakan MutableSet di Kotlin

Kita akan menggunakan MutableSet dalam contoh ini untuk menunjukkan cara menambahkan dan menghapus elemen.

  1. Hapus kode yang ada dari main().
  2. Buat Set planet yang disebut solarSystem menggunakan mutableSetOf(). Tindakan ini akan menampilkan MutableSet, yang implementasi defaultnya adalah LinkedHashSet().
val solarSystem = mutableSetOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
  1. Cetak ukuran set menggunakan properti size.
println(solarSystem.size)
  1. Seperti List, Set memiliki metode add(). Tambahkan "Pluto" ke set solarSystem menggunakan metode add(). Hanya dibutuhkan satu parameter agar elemen dapat ditambahkan. Elemen dalam set tidak harus memiliki urutan, jadi tidak ada indeks.
solarSystem.add("Pluto")
  1. Cetak size set setelah menambahkan elemen.
println(solarSystem.size)
  1. Fungsi contains() mengambil satu parameter dan memeriksa apakah elemen yang ditentukan terdapat dalam set. Jika ya, true akan ditampilkan. Jika tidak, false akan ditampilkan. Panggil contains() untuk memeriksa apakah "Pluto" ada di solarSystem.
println(solarSystem.contains("Pluto"))
  1. Jalankan kode. Ukuran telah bertambah dan contains() sekarang menampilkan true.
8
9
true
  1. Seperti yang disebutkan sebelumnya, set tidak boleh berisi duplikat. Coba tambahkan kembali "Pluto".
solarSystem.add("Pluto")
  1. Cetak kembali ukuran set.
println(solarSystem.size)
  1. Jalankan lagi kode. "Pluto" tidak ditambahkan karena sudah ada dalam set. Ukuran seharusnya tidak bertambah kali ini.
...
9

Fungsi remove() mengambil satu parameter dan menghapus elemen yang ditentukan dari set.

  1. Gunakan fungsi remove() untuk menghapus "Pluto".
solarSystem.remove("Pluto")
  1. Cetak ukuran koleksi dan panggil contains() lagi untuk memeriksa apakah "Pluto" masih berada dalam set.
println(solarSystem.size)
println(solarSystem.contains("Pluto"))
  1. Jalankan kode. "Pluto" tidak lagi ada dalam set dan sekarang ukurannya menjadi 8.
...
8
false

5. Koleksi peta

Map adalah koleksi yang terdiri dari kunci dan nilai. Disebut peta karena kunci unik dipetakan ke nilai lain. Kunci dan nilai yang menyertainya sering disebut key-value pair.

8571494fb4a106b6.png

Kunci peta bersifat unik. Namun, nilai peta tidak demikian. Dua kunci yang berbeda dapat dipetakan ke nilai yang sama. Misalnya, "Mercury" memiliki 0 bulan, dan "Venus" memiliki 0 bulan.

Mengakses nilai dari peta berdasarkan kuncinya biasanya lebih cepat daripada menelusuri daftar besar, seperti dengan indexOf().

Peta dapat dideklarasikan menggunakan fungsi mapOf() atau mutableMapOf(). Peta memerlukan dua jenis generik yang dipisahkan koma—satu untuk kunci dan satu lagi untuk nilai.

affc23a0e1f2b223.png

Peta juga dapat menggunakan inferensi jenis jika memiliki nilai awal. Untuk mengisi peta dengan nilai awal, setiap pasangan nilai kunci terdiri dari kunci, diikuti dengan operator to, yang diikuti dengan nilai. Setiap pasangan dipisahkan oleh koma.

8719ffc353f652f.png

Mari kita pelajari lebih lanjut cara menggunakan peta, serta beberapa properti dan metode yang berguna.

  1. Hapus kode yang ada dari main().
  2. Buat peta bernama solarSystem menggunakan mutableMapOf() dengan nilai awal seperti yang ditunjukkan.
val solarSystem = mutableMapOf(
    "Mercury" to 0,
    "Venus" to 0,
    "Earth" to 1,
    "Mars" to 2,
    "Jupiter" to 79,
    "Saturn" to 82,
    "Uranus" to 27,
    "Neptune" to 14
)
  1. Seperti daftar dan set, Map menyediakan properti size, yang berisi jumlah pasangan nilai kunci. Cetak ukuran peta solarSystem.
println(solarSystem.size)
  1. Anda dapat menggunakan sintaksis subskrip untuk menetapkan key-value pair tambahan. Tetapkan kunci "Pluto" ke nilai 5.
solarSystem["Pluto"] = 5
  1. Cetak kembali ukuran, setelah menyisipkan elemen.
println(solarSystem.size)
  1. Anda dapat menggunakan sintaksis subskrip untuk mendapatkan nilai. Cetak jumlah bulan untuk kunci "Pluto".
println(solarSystem["Pluto"])
  1. Anda juga dapat mengakses nilai dengan metode get(). Baik Anda menggunakan sintaksis subskrip atau memanggil get(), mungkin kunci yang Anda teruskan tidak ada dalam peta. Jika tidak ada pasangan nilai kunci, nilai akan menampilkan null. Cetak jumlah bulan untuk "Theia".
println(solarSystem["Theia"])
  1. Jalankan kode. Jumlah bulan untuk Pluto akan dicetak. Namun, karena Theia tidak ada di peta, memanggil get() akan menampilkan null.
8
9
5
null

Metode remove() menghapus key-value pair dengan kunci yang ditentukan. Nilai yang dihapus atau null juga akan ditampilkan jika kunci yang ditentukan tidak ada di peta.

  1. Cetak hasil dari panggilan remove() dan teruskan "Pluto".
solarSystem.remove("Pluto")
  1. Untuk memverifikasi bahwa item tersebut telah dihapus, cetak kembali ukurannya.
println(solarSystem.size)
  1. Jalankan kode. Ukuran peta adalah 8 setelah menghapus entri.
...
8
  1. Sintaksis subskrip, atau metode put(), juga dapat mengubah nilai untuk kunci yang sudah ada. Gunakan sintaksis subskrip untuk mengupdate bulan Jupiter menjadi 78 dan cetak nilai baru.
solarSystem["Jupiter"] = 78
println(solarSystem["Jupiter"])
  1. Jalankan kode. Nilai untuk kunci yang ada, "Jupiter", diupdate.
...
78

6. Kesimpulan

Selamat! Anda telah mempelajari salah satu jenis data yang paling mendasar dalam pemrograman, array, dan beberapa jenis koleksi data praktis yang dibuat dari array, termasuk List, Set, dan Map. Jenis koleksi ini memungkinkan Anda mengelompokkan dan mengatur nilai dalam kode. Array dan daftar menyediakan akses cepat ke elemen berdasarkan indeksnya, sedangkan set dan peta menggunakan kode hash untuk mempermudah menemukan elemen dalam koleksi. Anda akan melihat jenis koleksi ini sering digunakan di aplikasi mendatang, dan mengetahui cara menggunakannya akan menguntungkan Anda dalam karier pemrograman di masa mendatang.

Ringkasan

  • Array menyimpan data yang diurutkan dengan jenis yang sama dan memiliki ukuran tetap.
  • Array digunakan untuk mengimplementasikan banyak jenis koleksi lainnya.
  • Daftar adalah koleksi yang diurutkan dan dapat diubah ukurannya.
  • Set adalah koleksi yang tidak berurutan dan tidak boleh berisi duplikat.
  • Cara kerja peta mirip dengan set dan penyimpanan pasangan kunci dan nilai dari jenis yang ditentukan.

7. Pelajari lebih lanjut