Menggunakan List (Daftar) di Kotlin

1. Sebelum memulai

Dalam kehidupan sehari-hari, membuat daftar untuk berbagai situasi adalah hal yang umum dilakukan, seperti daftar hal yang harus dilakukan, daftar tamu untuk suatu acara, daftar keinginan, atau daftar belanja. Dalam pemrograman, daftar juga sangat berguna. Misalnya seperti daftar artikel berita, lagu, acara kalender, atau postingan media sosial dalam aplikasi.

Mempelajari cara membuat dan menggunakan daftar merupakan konsep pemrograman yang penting untuk ditambahkan ke toolbox, dan memungkinkan Anda dapat membuat aplikasi yang lebih canggih.

Di codelab ini, Anda akan menggunakan Kotlin Playground untuk membiasakan diri dengan daftar di Kotlin dan membuat program untuk memesan berbagai variasi sup mi. Sudah lapar?

Prasyarat

Terbiasa menggunakan Kotlin Playground untuk membuat dan mengedit program Kotlin.
Memahami konsep dasar pemrograman Kotlin dari Unit 1 Dasar-Dasar Android dalam kursus Kotlin: fungsi main(), argumen fungsi dan nilai yang ditampilkan, variabel, jenis data dan operasi, serta pernyataan alur kontrol.
Mampu menentukan class Kotlin, membuat instance objek darinya, serta mengakses properti dan metodenya.
Mampu membuat subclass dan memahami cara subclass dapat mewarisi satu sama lain.

Yang akan Anda pelajari

Cara membuat dan menggunakan daftar di Kotlin.
Perbedaan antara List dan MutableList, dan kapan harus menggunakan keduanya
Cara melakukan iterasi pada semua item di daftar dan menjalankan tindakan pada setiap item tersebut.

Yang akan Anda bangun

Anda akan melakukan eksperimen dengan daftar dan operasi daftar di Kotlin Playground.
Anda akan membuat program pemesanan makanan menggunakan daftar di Kotlin Playground.
Program Anda akan dapat membuat pesanan, menambahkan mi dan sayuran ke dalamnya, serta menghitung total biaya pesanan.

Yang Anda perlukan

Komputer yang terhubung dengan koneksi internet untuk mengakses Kotlin Playground.

2. Pengantar Daftar

Di codelab sebelumnya, Anda mempelajari jenis data dasar di Kotlin seperti Int, Double, Boolean, dan String. Jenis data tersebut memungkinkan Anda untuk menyimpan jenis nilai tertentu dalam sebuah variabel. Namun, bagaimana jika Anda ingin menyimpan lebih dari satu nilai? Maka akan sangat berguna jika memiliki jenis data List.

Daftar merupakan koleksi beberapa item dengan pesanan tertentu. Terdapat dua jenis daftar di Kotlin:

Daftar hanya baca: List tidak dapat diubah setelah dibuat.
Daftar yang dapat diubah: MutableList dapat diubah setelah dibuat. Artinya, Anda dapat menambah, menghapus, dan memperbarui elemennya.

Saat menggunakan List atau MutableList, Anda harus menentukan jenis elemen yang dapat diisinya. Misalnya, List<Int> menyimpan daftar bilangan bulat dan List<String> menyimpan daftar String. Jika menentukan class Car di program, Anda dapat memiliki List<Car> yang menyimpan daftar instance objek Car.

Cara terbaik untuk memahami daftar adalah dengan mencobanya.

Membuat Daftar

Buka Kotlin Playground lalu hapus kode yang disediakan.
Tambahkan fungsi main() yang kosong. Semua langkah kode berikut akan masuk ke dalam fungsi main().

fun main() {

}

Di dalam main(), buat variabel bernama numbers dari jenis List<Int> karena variabel tersebut akan berisi daftar bilangan bulat hanya baca. Buat List baru menggunakan fungsi library standar Kotlin listOf(), lalu teruskan elemen daftar sebagai argumen yang dipisahkan oleh koma. listOf(1, 2, 3, 4, 5, 6) akan menampilkan daftar bilangan bulat hanya baca antara 1 sampai 6.

val numbers: List<Int> = listOf(1, 2, 3, 4, 5, 6)

Jika jenis variabel dapat ditebak (atau disimpulkan) berdasarkan nilai pada sisi kanan operator penetapan (=), jenis data variabel dapat dihilangkan. Oleh karena itu, Anda dapat memperpendek baris kode berikut:

val numbers = listOf(1, 2, 3, 4, 5, 6)

Gunakan println() untuk mencetak daftar numbers.

println("List: $numbers")

Perlu diingat bahwa membubuhkan $ ke dalam string berarti hal yang mengikutinya merupakan sebuah ekspresi yang akan dievaluasi dan ditambahkan ke string ini (lihat template string). Baris kode ini juga dapat ditulis dengan println("List: " + numbers).

Ambil ukuran daftar menggunakan properti numbers.size, lalu cetak.

println("Size: ${numbers.size}")

Jalankan program Anda. Outputnya adalah daftar dari semua elemen dan ukuran daftar. Perlu diperhatikan bahwa tanda kurung [], menunjukkan bahwa ini sebuah List. Di dalam tanda kurung terdapat elemen numbers yang dipisah oleh koma. Perlu diperhatikan juga elemennya berada dalam urutan yang sama saat Anda membuatnya.

List: [1, 2, 3, 4, 5, 6]
Size: 6

Mengakses elemen daftar

Fungsionalitas khusus untuk daftar adalah Anda dapat mengakses setiap elemen daftar berdasarkan indeksnya dengan bilangan bulat yang merepresentasikan posisi. Di bawah ini merupakan diagram dari daftar numbers yang telah kami buat. Diagram tersebut menampilkan setiap elemen dan indeks yang sesuai.

Indeks sebenarnya merupakan offset dari elemen pertama. Misalnya, ketika Anda mengatakan list[2], Anda bukan meminta elemen kedua dari daftar, tapi untuk meminta elemen dengan offset 2 posisi dari elemen pertama. Oleh karena itu, list[0] adalah elemen pertama (offset nol), list[1] adalah elemen kedua (offset 1), list[2] adalah elemen ketiga (offset 2), dan seterusnya.

Tambahkan kode berikut setelah kode yang ada dalam fungsi main(). Lalu, jalankan kode setelah setiap langkah, sehingga Anda bisa memverifikasi output yang diharapkan.

Cetak elemen pertama dari daftar di indeks 0. Anda dapat memanggil fungsi get() dengan indeks yang diinginkan sebagai numbers.get(0) atau Anda dapat menggunakan sintaksis singkat dengan tanda kurung siku di sekitar indeks sebagai numbers[0].

println("First element: ${numbers[0]}")

Berikutnya, cetak elemen kedua dari daftar di indeks 1.

println("Second element: ${numbers[1]}")

Nilai indeks yang valid ("indeks") dari daftar berawal dari 0 ke indeks terakhir yang merupakan ukuran daftar minus 1. Artinya, indeks berjalan dari 0 ke 5 untuk daftar numbers Anda.

Cetak elemen terakhir dari daftar, menggunakan numbers.size - 1 untuk menghitung indeksnya, yang seharusnya 5. Mengakses elemen di indeks kelima harus menampilkan 6 sebagai output.

println("Last index: ${numbers.size - 1}")
println("Last element: ${numbers[numbers.size - 1]}")

Kotlin juga mendukung operasi first() dan last() pada daftar. Coba panggil numbers.first() dan numbers.last() lalu lihat outputnya.

println("First: ${numbers.first()}")
println("Last: ${numbers.last()}")

Anda akan melihat numbers.first() menampilkan elemen pertama dari daftar dan numbers.last() menampilkan elemen terakhir dari daftar.

Operasi daftar lain yang berguna adalah metode contains() yang berfungsi untuk mengetahui apakah elemen tertentu ada dalam daftar. Misalnya, jika Anda memiliki daftar nama karyawan di sebuah perusahaan, Anda dapat menggunakan metode contains() untuk mengetahui apakah nama tersebut ada dalam daftar.

Pada daftar numbers, panggil metode contains() dengan salah satu bilangan bulat yang ada dalam daftar. numbers.contains(4) akan menampilkan nilai true. Lalu, panggil metode contains() dengan bilangan bulat yang tidak ada dalam daftar. numbers.contains(7) akan menampilkan false.

println("Contains 4? ${numbers.contains(4)}")
println("Contains 7? ${numbers.contains(7)}")

Kode yang sudah selesai akan terlihat seperti ini. Komentar bersifat opsional.

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    println("List: $numbers")
    println("Size: ${numbers.size}")

    // Access elements of the list
    println("First element: ${numbers[0]}")
    println("Second element: ${numbers[1]}")
    println("Last index: ${numbers.size - 1}")
    println("Last element: ${numbers[numbers.size - 1]}")
    println("First: ${numbers.first()}")
    println("Last: ${numbers.last()}")

    // Use the contains() method
    println("Contains 4? ${numbers.contains(4)}")
    println("Contains 7? ${numbers.contains(7)}")
}

Jalankan kode. Outputnya akan terlihat seperti ini.

List: [1, 2, 3, 4, 5, 6]
Size: 6
First element: 1
Second element: 2
Last index: 5
Last element: 6
First: 1
Last: 6
Contains 4? true
Contains 7? false

Daftar hanya untuk dibaca

Hapus kode dalam Kotlin Playground lalu ganti dengan kode berikut. Daftar colors diinisialisasi ke daftar 3 warna yang ditampilkan sebagai Strings.

fun main() {
    val colors = listOf("green", "orange", "blue")
}

Perlu diingat bahwa Anda tidak dapat menambah atau mengubah elemen dalam List hanya baca. Lihat apa yang terjadi jika Anda mencoba untuk menambah sebuah item ke daftar atau mencoba untuk mengubah sebuah elemen daftar dengan menyetelnya sama dengan nilai baru.

colors.add("purple")
colors[0] = "yellow"

Jalankan kode tersebut dan Anda akan mendapatkan beberapa pesan error. Intinya adalah error tersebut memperlihatkan bahwa metode add() tidak dapat digunakan untuk List, dan Anda tidak diizinkan untuk mengubah nilai elemen.

Hapus kode yang salah.

Anda telah melihat secara langsung bahwa daftar hanya baca tidak mungkin bisa untuk diubah. Namun, ada beberapa operasi dalam daftar yang tidak mengubah daftar, tetapi dapat menampilkan daftar baru. Dua di antaranya yaitu reversed() dan sorted(). Fungsi reversed() menampilkan daftar baru yang elemennya berada dalam urutan terbalik, sedangkan fungsi sorted() menampilkan daftar baru yang elemennya diurutkan dalam urutan menaik.

Tambahkan kode untuk membalikkan daftar colors. Cetak outputnya. Daftar ini merupakan daftar baru yang berisi elemen colors dalam urutan terbalik.
Tambahkan kode baris kedua untuk mencetak list asli, sehingga Anda dapat melihat daftar asli yang tidak diubah.

println("Reversed list: ${colors.reversed()}")
println("List: $colors")

Di bawah ini merupakan output dari dua daftar yang telah dicetak.

Reversed list: [blue, orange, green]
List: [green, orange, blue]

Tambahkan kode untuk menampilkan List versi yang diurutkan menggunakan fungsi sorted().

println("Sorted list: ${colors.sorted()}")

Outputnya adalah daftar warna baru yang diurutkan dalam urutan abjad. Keren!

Sorted list: [blue, green, orange]

Anda juga dapat mencoba fungsi sorted() di daftar nomor yang tidak diurutkan.

val oddNumbers = listOf(5, 3, 7, 1)
println("List: $oddNumbers")
println("Sorted list: ${oddNumbers.sorted()}")

List: [5, 3, 7, 1]
Sorted list: [1, 3, 5, 7]

Sekarang, Anda dapat melihat manfaat dari membuat daftar. Namun, akan lebih baik jika Anda dapat mengubah daftar setelah dibuat. Jadi, mari kita lihat daftar yang dapat diubah selanjutnya.

3. Pengantar Daftar yang Dapat Diubah

Daftar yang dapat diubah adalah daftar yang dapat dimodifikasi setelah dibuat. Anda dapat menambah, menghapus, atau mengubah item. Anda juga dapat melakukan apa pun yang dapat dilakukan dengan daftar hanya baca. Daftar yang dapat diubah adalah jenis MutableList, dan Anda dapat membuatnya dengan memanggil mutableListOf().

Membuat MutableList

Hapus kode yang ada di main().
Di dalam fungsi main(), buat daftar kosong yang dapat berubah dan tetapkan daftar tersebut ke variabel val yang disebut entrees.

val entrees = mutableListOf()

Jika Anda mencoba menjalankan kode, hasilnya dapat menyebabkan error berikut.

Not enough information to infer type variable T

Seperti yang sudah disebutkan sebelumnya, ketika Anda membuat MutableList atau List, Kotlin mencoba menyimpulkan jenis elemen yang terdapat dalam daftar dari argumen yang diteruskan. Misalnya, jika Anda menulis listOf("noodles"), Kotlin akan membuat kesimpulan bahwa Anda ingin membuat daftar String. Saat Anda menginisialisasi daftar kosong tanpa elemen, Kotlin tidak dapat menyimpulkan jenis dari elemen itu, sehingga Anda harus menyatakan sendiri jenisnya secara eksplisit. Lakukan hal tersebut dengan menambah jenis dalam tanda kurung siku tepat setelah mutableListOf atau listOf. (Di dokumentasi, Anda mungkin akan melihat ini sebagai <T> yang mana T merupakan singkatan parameter jenis).

Perbaiki pernyataan variabel untuk menentukan bahwa Anda ingin membuat daftar jenis String yang dapat diubah.

val entrees = mutableListOf<String>()

Cara lain untuk memperbaiki error yaitu dengan menentukan jenis data dari variabel di awal.

val entrees: MutableList<String> = mutableListOf()

Cetak daftarnya.

println("Entrees: $entrees")

Output akan menampilkan [] untuk daftar kosong.

Entrees: []

Menambahkan elemen ke daftar

Daftar yang dapat diubah dapat menjadi menarik saat Anda menambah, menghapus, dan memperbarui elemen.

Tambahkan "noodles" ke daftar dengan entrees.add("noodles"). Jika berhasil menambahkan elemen ke daftar, fungsi add() akan menampilkan true. Jika tidak berhasil, maka akan menampilkan false.
Cetak daftar untuk memastikan bahwa "noodles" benar-benar telah ditambahkan.

println("Add noodles: ${entrees.add("noodles")}")
println("Entrees: $entrees")

Outputnya adalah:

Add noodles: true
Entrees: [noodles]

Tambahkan item lain "spaghetti" ke daftar.

println("Add spaghetti: ${entrees.add("spaghetti")}")
println("Entrees: $entrees")

Daftar entrees yang dihasilkan sekarang berisi dua item.

Add spaghetti: true
Entrees: [noodles, spaghetti]

Daripada menambahkan elemen satu per satu menggunakan add(), Anda dapat menambahkan beberapa elemen sekaligus dengan addAll() dan meneruskan daftar.

Buat daftar moreItems. Anda tidak perlu mengubahnya. Maka, buatlah menjadi val dan tidak dapat diubah.

val moreItems = listOf("ravioli", "lasagna", "fettuccine")

Dengan menggunakan addAll(), tambahkan semua item dari daftar baru ke entrees. Lalu cetak daftar yang dihasilkan.

println("Add list: ${entrees.addAll(moreItems)}")
println("Entrees: $entrees")

Output akan menampilkan bahwa daftar berhasil ditambahkan. Daftar entrees sekarang memiliki total 5 item.

Add list: true
Entrees: [noodles, spaghetti, ravioli, lasagna, fettuccine]

Sekarang, coba tambahkan angka ke daftar.

entrees.add(10)

Proses ini gagal dengan error:

The integer literal does not conform to the expected type String

Hal ini dikarenakan daftar entrees mengharapkan elemen dengan jenis String, sedangkan Anda mencoba menambahkan Int. Ingatlah agar hanya menambahkan elemen dari jenis data yang benar ke daftar. Jika tidak, Anda akan mengalami error kompilasi. Hal tersebut merupakan salah satu cara Kotlin untuk memastikan kode Anda lebih aman dengan keamanan jenis.

Hapus baris kode yang salah, sehingga kode Anda akan terkompilasi.

Menghapus elemen dari daftar

Panggil remove() untuk menghapus "spaghetti" dari daftar. Cetak kembali daftar tersebut.

println("Remove spaghetti: ${entrees.remove("spaghetti")}")
println("Entrees: $entrees")

Menghapus "spaghetti" akan menampilkan nilai true karena elemen tersebut ada dalam daftar dan telah berhasil dihapus. Kini daftarnya hanya berisi 4 item tersisa.

Remove spaghetti: true
Entrees: [noodles, ravioli, lasagna, fettuccine]

Apa yang akan terjadi jika Anda mencoba menghapus item yang tidak ada dalam daftar? Coba hapus "rice" dari daftar dengan entrees.remove("rice").

println("Remove item that doesn't exist: ${entrees.remove("rice")}")
println("Entrees: $entrees")

Metode remove() menampilkan false, karena elemen tersebut tidak ada sehingga tidak dapat dihapus. Daftar tersebut tidak berubah dengan 4 item yang masih tersisa. Output:

Remove item that doesn't exist: false
Entrees: [noodles, ravioli, lasagna, fettuccine]

Anda juga dapat menentukan indeks elemen yang akan dihapus. Gunakan removeAt() untuk menghapus item pada indeks 0.

println("Remove first element: ${entrees.removeAt(0)}")
println("Entrees: $entrees")

Nilai yang ditampilkan removeAt(0) adalah elemen pertama ("noodles") yang dihapus dari daftar. Daftar entrees sekarang memiliki 3 item yang tersisa.

Remove first element: noodles
Entrees: [ravioli, lasagna, fettuccine]

Jika ingin mengosongkan seluruh daftar, Anda dapat memanggil clear().

entrees.clear()
println("Entrees: $entrees")

Sekarang output menampilkan daftar kosong.

Entrees: []

Kotlin memberikan cara untuk memeriksa apakah daftar kosong menggunakan fungsi isEmpty(). Coba cetak entrees.isEmpty().

println("Empty? ${entrees.isEmpty()}")

Outputnya harus berupa true karena daftar saat ini kosong dengan 0 elemen.

Empty? true

Metode isEmpty() akan berguna jika Anda ingin melakukan operasi pada daftar atau mengakses elemen tertentu. Namun, Anda ingin memastikan terlebih dahulu bahwa daftar tidak kosong.

Berikut ini merupakan semua kode yang Anda tulis untuk daftar yang dapat diubah. Komentar bersifat opsional.

fun main() {
    val entrees = mutableListOf<String>()
    println("Entrees: $entrees")

    // Add individual items using add()
    println("Add noodles: ${entrees.add("noodles")}")
    println("Entrees: $entrees")
    println("Add spaghetti: ${entrees.add("spaghetti")}")
    println("Entrees: $entrees")

    // Add a list of items using addAll()
    val moreItems = listOf("ravioli", "lasagna", "fettuccine")
    println("Add list: ${entrees.addAll(moreItems)}")
    println("Entrees: $entrees")

    // Remove an item using remove()
    println("Remove spaghetti: ${entrees.remove("spaghetti")}")
    println("Entrees: $entrees")
    println("Remove item that doesn't exist: ${entrees.remove("rice")}")
    println("Entrees: $entrees")

    // Remove an item using removeAt() with an index
    println("Remove first element: ${entrees.removeAt(0)}")
    println("Entrees: $entrees")

    // Clear out the list
    entrees.clear()
    println("Entrees: $entrees")

    // Check if the list is empty
    println("Empty? ${entrees.isEmpty()}")
}

4. Melakukan Loop Melewati Daftar

Untuk menjalankan operasi pada setiap item dalam daftar, Anda dapat membuat loop melalui daftar (juga dikenal sebagai iterasi melalui daftar). Loop dapat digunakan dengan Lists dan MutableLists.

Loop while

Salah satu jenis loop adalah loop while. Loop while dimulai dengan kata kunci while di Kotlin. Loop ini berisi blok kode (dalam kurung kurawal) yang dijalankan berulang kali selama ekspresi dalam tanda kurung adalah true. Untuk mencegah kode berjalan terus menerus (disebut loop tak terbatas), blok kode harus berisi logika yang dapat mengubah nilai ekspresi, sehingga nantinya ekspresi tersebut akan menjadi false dan Anda akan berhenti menjalankan loop. Pada saat tersebut, Anda akan keluar dari loop while lalu melanjutkan dengan menjalankan kode yang muncul setelah loop.

while (expression) {
    // While the expression is true, execute this code block
}

Gunakan loop while untuk melakukan iterasi melalui daftar. Buat variabel untuk melacak index yang saat ini Anda lihat dalam daftar. Variabel index ini akan terus bertambah 1 pada tiap iterasi hingga Anda mencapai indeks terakhir dalam daftar, setelah itu Anda keluar dari loop.

Hapus kode yang sudah ada di Kotlin Playground dan miliki fungsi main() yang kosong.
Anggaplah Anda sedang mengadakan pesta. Buatlah daftar yang setiap elemennya mewakili jumlah tamu RSVP dari setiap keluarga. Keluarga pertama mengatakan 2 orang akan datang dari keluarga mereka. Keluarga kedua mengatakan 4 dari mereka akan datang, dan seterusnya.

val guestsPerFamily = listOf(2, 4, 1, 3)

Cari tahu jumlah total tamu yang akan datang. Tulis loop untuk menemukan jawabannya. Buat var untuk jumlah tamu dan inisialisasikan ke 0.

var totalGuests = 0

Inisialisasikan var untuk variabel index, seperti yang dijelaskan sebelumnya.

var index = 0

Tulis loop while untuk melakukan iterasi melalui daftar. Kondisinya adalah selama nilai index lebih kecil dari ukuran daftar, blok kode dapat terus berjalan.

while (index < guestsPerFamily.size) {

}

Di dalam loop, dapatkan elemen daftar pada index saat ini dan tambahkan elemen tersebut ke jumlah total variabel tamu. Perlu diingat bahwa totalGuests += guestsPerFamily[index] sama dengan totalGuests = totalGuests + guestsPerFamily[index].

Perhatikan bahwa baris terakhir loop menambah variabel index sebesar 1 menggunakan index++, sehingga iterasi loop berikutnya akan melihat kelompok keluarga selanjutnya dalam daftar.

while (index < guestsPerFamily.size) {
    totalGuests += guestsPerFamily[index]
    index++
}

Setelah loop while, Anda dapat mencetak hasilnya.

while ... {
    ...
}
println("Total Guest Count: $totalGuests")

Jalankan program dan outputnya adalah sebagai berikut. Anda dapat memverifikasi bahwa output tersebut adalah jawaban yang benar dengan menambahkan angka dalam daftar secara manual.

Total Guest Count: 10

Berikut cuplikan kode lengkapnya:

val guestsPerFamily = listOf(2, 4, 1, 3)
var totalGuests = 0
var index = 0
while (index < guestsPerFamily.size) {
    totalGuests += guestsPerFamily[index]
    index++
}
println("Total Guest Count: $totalGuests")

Dengan loop while, Anda harus menulis kode untuk membuat variabel yang dapat melacak indeks, mendapatkan elemen pada indeks dalam daftar, serta memperbarui variabel indeks. Ada cara yang lebih cepat dan lebih ringkas untuk membuat iterasi pada daftar. Gunakan loop for!

Loop for

Loop for adalah jenis loop lainnya. Loop ini membuat pengulangan dalam daftar menjadi lebih mudah. Dimulai dengan kata kunci for di Kotlin dengan blok kode dalam kurung kurawal. Kondisi untuk menjalankan blok kode dinyatakan dalam tanda kurung.

for (number in numberList) {
   // For each element in the list, execute this code block
}

Pada contoh di atas, variabel number disetel sama dengan elemen pertama numberList, dan blok kode dijalankan. Lalu, variabel number akan diperbarui secara otomatis menjadi elemen numberList berikutnya yang kemudian blok kode dijalankan lagi. Penyetelan ini berulang untuk setiap elemen daftar, sampai akhir numberList tercapai.

Hapus kode yang sudah ada di Kotlin Playground dan ganti dengan kode berikut:

fun main() {
    val names = listOf("Jessica", "Henry", "Alicia", "Jose")
}

Tambahkan loop for untuk mencetak semua item di daftar names.

for (name in names) {
    println(name)
}

Penambahan ini jauh lebih mudah dibandingkan Anda harus menuliskannya sebagai loop while.

Outputnya adalah:

Jessica
Henry
Alicia
Jose

Operasi umum pada daftar adalah melakukan sesuatu dengan setiap elemen daftar.

Ubah loop untuk mencetak jumlah karakter dalam nama orang tersebut. Petunjuk: Anda dapat menggunakan properti length dari String untuk menemukan jumlah karakter dalam String tersebut.

val names = listOf("Jessica", "Henry", "Alicia", "Jose")
for (name in names) {
    println("$name - Number of characters: ${name.length}")
}

Output:

Jessica - Number of characters: 7
Henry - Number of characters: 5
Alicia - Number of characters: 6
Jose - Number of characters: 4

Kode di loop tidak mengubah List asli. Kode ini hanya akan memengaruhi apa yang dicetak.

Anda dapat menulis petunjuk tentang apa yang harus terjadi untuk 1 item daftar, dan kode dijalankan untuk setiap item daftar dengan mudah! Menggunakan loop dapat menghindarkan Anda dari mengetik banyak kode berulang.

Setelah Anda bereksperimen dengan membuat serta menggunakan daftar dan daftar yang dapat diubah, juga mempelajari tentang loop, sekarang saatnya untuk menerapkan kemampuan ini dalam contoh kasus penggunaan!

5. Menyatukan semuanya

Dalam hal memesan makanan di restoran lokal, biasanya ada beberapa item dalam satu pesanan untuk pelanggan. Penggunaan daftar sangat ideal untuk menyimpan informasi tentang pesanan. Anda juga akan memanfaatkan pengetahuan tentang class dan pewarisan untuk membuat program Kotlin yang lebih andal dan skalabel, bukan menempatkan semua kode dalam fungsi main().

Untuk seri tugas berikutnya, buat program Kotlin yang memungkinkan untuk memesan kombinasi makanan yang berbeda.

Pertama, perhatikan contoh output dari kode akhir ini. Dapatkah Anda memikirkan jenis class yang perlu Anda buat untuk membantu mengatur semua data ini?

Order #1
Noodles: $10
Total: $10

Order #2
Noodles: $10
Vegetables Chef's Choice: $5
Total: $15

Dari output tersebut, Anda akan melihat:

daftar pesanan
setiap pesanan memiliki nomor
setiap pesanan berisi daftar item seperti mi dan sayuran
setiap item memiliki harga
setiap pesanan memiliki harga total, yang merupakan jumlah harga dari setiap item

Anda dapat membuat class untuk menampilkan Order, dan class untuk menampilkan setiap item makanan seperti Noodles atau Vegetables. Anda dapat melihat bahwa Noodles dan Vegetables memiliki beberapa kemiripan karena keduanya merupakan item makanan dan masing-masing memiliki harga. Anda dapat mempertimbangkan untuk membuat class Item dengan properti bersama yang dapat diwariskan oleh class Noodle dan class Vegetable. Dengan begitu, Anda tidak perlu menduplikasi logika di class Noodle dan Vegetable.

Anda akan disediakan kode awal berikut. Developer profesional sering kali harus membaca kode orang lain, misalnya, jika mereka bergabung dengan project baru atau menambahkan ke fitur yang dibuat orang lain. Kemampuan untuk membaca dan memahami kode adalah keahlian penting yang harus dimiliki.

Luangkan waktu untuk memeriksa kode ini dan untuk memahami apa yang terjadi. Salin dan tempel kode ini ke Kotlin Playground lalu jalankan. Pastikan untuk menghapus kode yang ada di Kotlin Playground sebelum menempelkan kode baru ini. Amati outputnya dan lihat apakah hal tersebut membantu Anda untuk memahami kode dengan lebih baik.

open class Item(val name: String, val price: Int)

class Noodles : Item("Noodles", 10)

class Vegetables : Item("Vegetables", 5)

fun main() {
    val noodles = Noodles()
    val vegetables = Vegetables()
    println(noodles)
    println(vegetables)
}

Anda akan melihat output yang serupa dengan ini:

Noodles@5451c3a8
Vegetables@76ed5528

Berikut penjelasan kode yang lebih mendetail. Pertama, terdapat class bernama Item, dengan konstruktor mengambil 2 parameter: name untuk item (sebagai String) dan price (sebagai bilangan bulat). Kedua properti tersebut tidak berubah setelah diteruskan, sehingga ditandai sebagai val. Karena Item adalah class induk, dan subclass diperluas dari class ini, maka class tersebut ditandai dengan kata kunci open.

Konstruktor class Noodles tidak menggunakan parameter apa pun, tetapi diperluas dari Item dan memanggil konstruktor superclass dengan memasukkan "Noodles" sebagai nama dan harga 10. Class Vegetables pun serupa, tetapi memanggil konstruksi superclass dengan "Vegetables" dan harga 5.

Fungsi main() melakukan inisialisasi instance objek baru dari class Noodles dan Vegetables, lalu mencetaknya ke output.

Mengganti metode toString()

Saat Anda mencetak instance objek ke output, metode toString() objek akan dipanggil. Di Kotlin, setiap class otomatis mewarisi metode toString(). Implementasi default dari metode ini hanya menampilkan jenis objek dengan alamat memori untuk instance. Anda harus mengganti toString() untuk menampilkan sesuatu yang lebih bermakna dan mudah digunakan dibandingkan dengan Noodles@5451c3a8 dan Vegetables@76ed5528.

Di dalam class Noodles, ganti metode toString() dan buat agar menampilkan name. Perlu diingat bahwa Noodles mewarisi properti name dari class induk Item.

class Noodles : Item("Noodles", 10) {
   override fun toString(): String {
       return name
   }
}

Ulangi hal yang sama untuk class Vegetables.

class Vegetables() : Item("Vegetables", 5) {
   override fun toString(): String {
       return name
   }
}

Jalankan kode. Outputnya akan terlihat lebih baik sekarang:

Noodles
Vegetables

Pada langkah berikutnya, Anda akan mengubah konstruktor class Vegetables untuk mengambil beberapa parameter, dan mengubah metode toString() untuk menggambarkan informasi tambahan tersebut.

Menyesuaikan sayuran dalam satu pesanan

Untuk membuat sup mi lebih menarik, Anda dapat menyertakan berbagai sayuran dalam pesanan Anda.

Di fungsi main(), berikan jenis sayuran tertentu yang diinginkan pelanggan, bukan melakukan inisialisasi instance Vegetables tanpa argumen input.

fun main() {
    ...
    val vegetables = Vegetables("Cabbage", "Sprouts", "Onion")
    ...
}

Jika Anda mencoba mengompilasi kode sekarang, akan terjadi error dengan pernyataan:

Too many arguments for public constructor Vegetables() defined in Vegetables

Sekarang Anda meneruskan 3 argumen String ke dalam konstruktor class Vegetables, sehingga Anda perlu mengubah class Vegetables.

Ubah header class Vegetables agar mengambil 3 parameter string, seperti yang ditunjukkan dalam kode berikut:

class Vegetables(val topping1: String,
                 val topping2: String,
                 val topping3: String) : Item ("Vegetables", 5) {

Sekarang kode Anda akan terkompilasi lagi. Namun, solusi ini hanya berfungsi jika pelanggan Anda ingin selalu memesan tiga sayuran. Jika pelanggan ingin memesan satu atau lima sayuran, mereka tidak beruntung.
Daripada menggunakan properti untuk setiap sayuran, Anda dapat memperbaiki masalah dengan menerima daftar sayuran (bisa berapa pun) di konstruktor untuk class Vegetables. List hanya boleh berisi Strings, karenanya jenis parameter input-nya adalah List<String>.

class Vegetables(val toppings: List<String>) : Item("Vegetables", 5) {

Langkah ini bukan solusi yang paling baik karena di main(), Anda harus mengubah kode untuk membuat daftar topping terlebih dahulu sebelum meneruskannya ke dalam konstruktor Vegetables.

Vegetables(listOf("Cabbage", "Sprouts", "Onion"))

Ada cara yang lebih baik untuk menyelesaikan masalah ini.

Di Kotlin, pengubah vararg memungkinkan Anda untuk meneruskan jumlah variabel argumen dari jenis yang sama ke dalam fungsi atau konstruktor. Dengan demikian, Anda dapat memasok sayuran berbeda sebagai string individual, bukan daftar.

Ubah definisi class Vegetables menjadi vararg toppings dari jenis String.

class Vegetables(vararg val toppings: String) : Item("Vegetables", 5) {

Kode dalam fungsi main() ini sekarang akan bekerja. Anda dapat membuat instance Vegetables dengan meneruskan sejumlah String topping.

fun main() {
    ...
    val vegetables = Vegetables("Cabbage", "Sprouts", "Onion")
    ...
}

Sekarang ubah metode toString() dari class Vegetables sehingga perubahan tersebut akan menampilkan String yang juga menyebutkan topping dalam format ini: Vegetables Cabbage, Sprouts, Onion.

Mulai dengan nama Item (Vegetables). Lalu gunakan metode joinToString() untuk menggabungkan semua topping ke dalam satu string. Tambahkan kedua bagian tersebut secara bersamaan menggunakan operator + dengan spasi di antara keduanya.

class Vegetables(vararg val toppings: String) : Item("Vegetables", 5) {
    override fun toString(): String {
        return name + " " + toppings.joinToString()
    }
}

Jalankan program Anda dan outputnya akan seperti berikut:

Noodles
Vegetables Cabbage, Sprouts, Onion

Saat menulis program, Anda perlu mempertimbangkan semua input yang memungkinkan. Jika tidak ada argumen input ke konstruktor Vegetables, tangani metode toString() dengan cara yang lebih mudah digunakan.

Karena pelanggan menginginkan sayuran, tetapi tidak menyebutkan yang mana, salah satu solusinya adalah memberi mereka sayuran pilihan koki secara default.

Ubah metode toString() agar menampilkan Vegetables Chef's Choice jika tidak ada topping yang diberikan. Manfaatkan metode isEmpty() yang Anda pelajari sebelumnya.

override fun toString(): String {
    if (toppings.isEmpty()) {
        return "$name Chef's Choice"
    } else {
        return name + " " + toppings.joinToString()
    }
}

Perbarui fungsi main() untuk menguji kedua kemungkinan yang membuat instance Vegetables tanpa argumen konstruktor apa pun dan dengan beberapa argumen.

fun main() {
    val noodles = Noodles()
    val vegetables = Vegetables("Cabbage", "Sprouts", "Onion")
    val vegetables2 = Vegetables()
    println(noodles)
    println(vegetables)
    println(vegetables2)
}

Verifikasi bahwa outputnya seperti yang diharapkan.

Noodles
Vegetables Cabbage, Sprouts, Onion
Vegetables Chef's Choice

Membuat pesanan

Setelah memiliki beberapa item makanan, Anda dapat membuat pesanan. Enkapsulasi logika untuk pesanan yang terdapat pada Order dalam program Anda.

Pikirkan tentang properti dan metode yang akan masuk akal untuk class Order. Jika dapat membantu, berikut beberapa contoh output dari kode akhir.

Order #1
Noodles: $10
Total: $10

Order #2
Noodles: $10
Vegetables Chef's Choice: $5
Total: $15

Order #3
Noodles: $10
Vegetables Carrots, Beans, Celery: $5
Total: $15

Order #4
Noodles: $10
Vegetables Cabbage, Onion: $5
Total: $15

Order #5
Noodles: $10
Noodles: $10
Vegetables Spinach: $5
Total: $25

Anda mungkin akan menemukan hal berikut:

Class order

Properti: jumlah pesanan, daftar item

Metode: menambahkan item, menambahkan beberapa item, mencetak ringkasan pesanan (termasuk harga)

Dengan berfokus pada properti terlebih dahulu, jenis data apa yang harus dimiliki setiap properti? Haruskah jenis data tersebut bersifat publik atau pribadi ke class? Haruskah jenis data tersebut diteruskan sebagai argumen atau didefinisikan di dalam class?
Ada beberapa cara untuk menerapkannya. Namun, berikut adalah salah satu solusinya. Buat class Order yang memiliki parameter konstruktor orderNumber bilangan bulat.

class Order(val orderNumber: Int)

Karena Anda mungkin tidak tahu semua item dalam pesanan di awal, jangan minta daftar item untuk diteruskan sebagai argumen. Sebagai gantinya, item dapat dinyatakan sebagai variabel class tingkat atas, dan item tersebut dapat diinisialisasi sebagai MutableList kosong yang dapat menampung elemen jenis Item. Tandai variabel private, sehingga hanya class ini yang dapat mengubah daftar item secara langsung. Langkah ini akan melindungi daftar agar tidak dimodifikasi dengan cara yang tidak diharapkan oleh kode di luar class ini.

class Order(val orderNumber: Int) {
    private val itemList = mutableListOf<Item>()
}

Lanjutkan dan tambahkan juga metode ke definisi class. Jangan ragu untuk memilih nama yang wajar untuk setiap metode, dan Anda dapat membiarkan logika penerapan dalam setiap metode untuk saat ini kosong. Selain itu, tentukan juga argumen fungsi dan nilai yang ditampilkan yang harus diperlukan.

class Order(val orderNumber: Int) {
   private val itemList = mutableListOf<Item>()

   fun addItem(newItem: Item) {
   }

   fun addAll(newItems: List<Item>) {
   }

   fun print() {
   }
}

Metode addItem() tampaknya paling mudah, jadi terapkan fungsi tersebut terlebih dahulu. Metode ini memerlukan Item baru dan harus menambahkannya ke itemList.

fun addItem(newItem: Item) {
    itemList.add(newItem)
}

Selanjutnya, terapkan metode addAll(). Metode ini hanya ada dalam daftar item hanya baca. Tambahkan semua item tersebut ke daftar internal item.

fun addAll(newItems: List<Item>) {
    itemList.addAll(newItems)
}

Lalu, terapkan metode print() yang akan mencetak ringkasan semua item termasuk harga ke output serta total harga pesanan.

Pertama, cetak nomor pesanan. Lalu gunakan loop untuk melakukan iterasi semua item di daftar pesanan. Cetak setiap item dan masing-masing harganya. Selain itu, simpan total harga sejauh ini, dan teruslah menambahkannya saat Anda melakukan iterasi pada daftar. Cetak harga total di bagian akhir. Coba terapkan logika ini sendiri. Jika Anda memerlukan bantuan, lihat solusi di bawah.

Anda mungkin ingin menyertakan simbol mata uang agar outputnya lebih mudah dibaca. Berikut ini salah satu cara untuk menerapkan solusi. Kode ini menggunakan simbol mata uang $, tetapi jangan ragu untuk memodifikasi ke simbol mata uang lokal Anda.

fun print() {
    println("Order #${orderNumber}")
    var total = 0
    for (item in itemList) {
        println("${item}: $${item.price}")
        total += item.price
    }
    println("Total: $${total}")
}

Untuk setiap item di itemList, cetak item (yang memicu toString() untuk dipanggil pada item) diikuti dengan price item tersebut. Juga sebelum loop, lakukan inisialisasi variabel bilangan bulat total menjadi 0. Lalu tambahkan ke totalnya dengan menambahkan harga item saat ini ke total.

Membuat Pesanan

Uji kode Anda dengan membuat instance Order dalam fungsi main(). Hapus apa yang saat ini Anda miliki di fungsi main() terlebih dahulu.
Anda dapat menggunakan contoh pesanan atau membuat pesanan Anda sendiri. Saat bereksperimen dengan berbagai kombinasi item di dalam pesanan, pastikan Anda menguji semua jalur kode di kode Anda. Misalnya, uji metode addItem() dan addAll() dalam class Order, lalu buat instance Vegetables dengan argumen dan tanpa argumen, dan seterusnya.

fun main() {
    val order1 = Order(1)
    order1.addItem(Noodles())
    order1.print()

    println()

    val order2 = Order(2)
    order2.addItem(Noodles())
    order2.addItem(Vegetables())
    order2.print()

    println()

    val order3 = Order(3)
    val items = listOf(Noodles(), Vegetables("Carrots", "Beans", "Celery"))
    order3.addAll(items)
    order3.print()
}

Output untuk kode di atas harus seperti berikut. Lakukan verifikasi bahwa penjumlahan harga total sudah benar.

Order #1
Noodles: $10
Total: $10

Order #2
Noodles: $10
Vegetables Chef's Choice: $5
Total: $15

Order #3
Noodles: $10
Vegetables Carrots, Beans, Celery: $5
Total: $15

Bagus. Sekarang terlihat seperti pesanan makanan, bukan?

6. Mengoptimalkan kode Anda

Menyimpan daftar pesanan

Jika Anda membangun program yang benar-benar akan digunakan di toko mi, akan masuk akal untuk melacak daftar semua pesanan pelanggan.

Buat daftar untuk menyimpan semua pesanan. Apakah daftar tersebut merupakan daftar hanya baca atau daftar yang dapat diubah?
Tambahkan kode ini ke fungsi main(). Lakukan inisialisasi daftar agar kosong di awalnya. Kemudian, setiap ada pesanan yang dibuat, tambahkan pesanan ke daftar.

fun main() {
    val ordersList = mutableListOf<Order>()

    val order1 = Order(1)
    order1.addItem(Noodles())
    ordersList.add(order1)

    val order2 = Order(2)
    order2.addItem(Noodles())
    order2.addItem(Vegetables())
    ordersList.add(order2)

    val order3 = Order(3)
    val items = listOf(Noodles(), Vegetables("Carrots", "Beans", "Celery"))
    order3.addAll(items)
    ordersList.add(order3)
}

Karena pesanan bertambah seiring waktu, daftar harus berupa MutableList jenis Order. Lalu gunakan metode add() di MutableList untuk menambahkan setiap pesanan.

Setelah Anda memiliki daftar pesanan, Anda dapat menggunakan loop untuk mencetak setiap pesanannya. Cetak baris kosong di antara pesanan sehingga output akan lebih mudah dibaca.

fun main() {
    val ordersList = mutableListOf<Order>()

    ...

    for (order in ordersList) {
        order.print()
        println()
    }
}

Langkah ini akan menghapus kode duplikat dalam fungsi main() dan membuat kode lebih mudah dibaca. Output harus sama seperti sebelumnya.

Menerapkan Pola Builder untuk Pesanan

Untuk membuat kode Kotlin menjadi lebih ringkas, Anda dapat menggunakan Pola Builder untuk membuat pesanan. Pola Builder adalah pola desain dalam pemrograman yang memungkinkan Anda untuk membangun objek kompleks dalam pendekatan tahap demi tahap.

Daripada menampilkan Unit (atau tidak sama sekali) dari metode addItem() dan addAll() di class Order, tampilkan Order yang telah diubah. Kotlin menyediakan kata kunci this untuk mereferensikan instance objek saat ini. Dalam metode addItem() dan addAll(), Anda akan menampilkan Order saat ini dengan menampilkan this.

fun addItem(newItem: Item): Order {
    itemList.add(newItem)
    return this
}

fun addAll(newItems: List<Item>): Order {
    itemList.addAll(newItems)
    return this
}

Pada fungsi main(), sekarang Anda dapat menyambungkan panggilan, seperti yang ditunjukkan pada kode berikut. Kode ini membuat Order baru dan memanfaatkan pola Builder.

val order4 = Order(4).addItem(Noodles()).addItem(Vegetables("Cabbage", "Onion"))
ordersList.add(order4)

Order(4) menampilkan instance Order yang kemudian dapat memanggil addItem(Noodles()). Metode addItem() menampilkan instance Order yang sama (dengan status baru), dan Anda dapat memanggil addItem() lagi dengan sayuran. Hasil Order yang ditampilkan dapat disimpan di variabel order4.

Kode yang ada untuk membuat Orders masih berfungsi, sehingga dapat dibiarkan tidak diubah. Meskipun tidak wajib untuk menghubungkan panggilan ini, praktik yang umum dan direkomendasikan adalah yang memanfaatkan nilai return fungsi.

Di tahap ini, Anda bahkan tidak perlu menyimpan pesanan dalam variabel. Dalam fungsi main() (sebelum loop terakhir untuk mencetak pesanan), buat Order secara langsung dan tambahkan ke orderList. Kode akan lebih mudah dibaca jika setiap panggilan metode dimasukkan ke barisnya masing-masing.

ordersList.add(
    Order(5)
        .addItem(Noodles())
        .addItem(Noodles())
        .addItem(Vegetables("Spinach")))

Jalankan kode Anda, dan berikut adalah output yang diharapkan:

Order #1
Noodles: $10
Total: $10

Order #2
Noodles: $10
Vegetables Chef's Choice: $5
Total: $15

Order #3
Noodles: $10
Vegetables Carrots, Beans, Celery: $5
Total: $15

Order #4
Noodles: $10
Vegetables Cabbage, Onion: $5
Total: $15

Order #5
Noodles: $10
Noodles: $10
Vegetables Spinach: $5
Total: $25

Selamat, Anda telah menyelesaikan codelab ini!

Sekarang Anda telah melihat betapa bergunanya menyimpan data dalam daftar, mengubah daftar, dan melakukan loop pada daftar. Gunakan pengetahuan ini dalam konteks aplikasi Android untuk menampilkan daftar data di layar pada codelab berikutnya.

7. Kode solusi

Berikut adalah kode solusi untuk class Item, Noodles, Vegetables, dan Order. Fungsi main() juga menunjukkan cara menggunakan class tersebut. Ada beberapa pendekatan untuk mengimplementasikan program ini, sehingga kode Anda mungkin akan sedikit berbeda.

open class Item(val name: String, val price: Int)

class Noodles : Item("Noodles", 10) {
    override fun toString(): String {
        return name
    }
}

class Vegetables(vararg val toppings: String) : Item("Vegetables", 5) {
    override fun toString(): String {
        if (toppings.isEmpty()) {
            return "$name Chef's Choice"
        } else {
            return name + " " + toppings.joinToString()
        }
    }
}

class Order(val orderNumber: Int) {
    private val itemList = mutableListOf<Item>()

    fun addItem(newItem: Item): Order {
        itemList.add(newItem)
        return this
    }

    fun addAll(newItems: List<Item>): Order {
        itemList.addAll(newItems)
        return this
    }

    fun print() {
        println("Order #${orderNumber}")
        var total = 0
        for (item in itemList) {
            println("${item}: $${item.price}")
            total += item.price
        }
        println("Total: $${total}")
    }
}

fun main() {
    val ordersList = mutableListOf<Order>()

    // Add an item to an order
    val order1 = Order(1)
    order1.addItem(Noodles())
    ordersList.add(order1)

    // Add multiple items individually
    val order2 = Order(2)
    order2.addItem(Noodles())
    order2.addItem(Vegetables())
    ordersList.add(order2)

    // Add a list of items at one time
    val order3 = Order(3)
    val items = listOf(Noodles(), Vegetables("Carrots", "Beans", "Celery"))
    order3.addAll(items)
    ordersList.add(order3)

    // Use builder pattern
    val order4 = Order(4)
        .addItem(Noodles())
        .addItem(Vegetables("Cabbage", "Onion"))
    ordersList.add(order4)

    // Create and add order directly
    ordersList.add(
        Order(5)
            .addItem(Noodles())
            .addItem(Noodles())
            .addItem(Vegetables("Spinach"))
    )

    // Print out each order
    for (order in ordersList) {
        order.print()
        println()
    }
}

8. Ringkasan

Kotlin menyediakan fungsi untuk membantu Anda mengelola dan memanipulasi koleksi data dengan lebih mudah melalui Library Standar Kotlin. Sebuah koleksi dapat ditentukan sebagai jumlah objek dengan jenis data yang sama. Terdapat beberapa jenis koleksi dasar di Kotlin: daftar, set, dan peta. Codelab ini secara khusus berfokus pada daftar, dan Anda akan mempelajari lebih lanjut set dan peta dalam codelab mendatang.

Daftar adalah urutan koleksi elemen dari jenis tertentu seperti daftar Strings.
Indeks adalah posisi bilangan bulat yang merefleksikan posisi elemen (misalnya myList[2]).
Dalam daftar, elemen pertama ada di indeks 0 (misalnya myList[0]), dan elemen terakhir ada di myList.size-1 (misalnya myList[myList.size-1] atau myList.last()).
Ada dua jenis daftar: List dan MutableList.
List bersifat hanya baca dan tidak dapat diubah setelah diinisialisasi. Namun, Anda dapat menerapkan operasi seperti sorted() dan reversed() yang menampilkan daftar baru tanpa mengubah yang asli.
MutableList dapat dimodifikasi setelah dibuat seperti menambah, menghapus, atau mengubah elemen.
Anda dapat menambahkan daftar item ke dalam daftar yang dapat diubah menggunakan addAll().
Gunakan loop while untuk menjalankan kode blok hingga ekspresi bernilai false dan Anda keluar dari loop.

while (expression) {

// While the expression is true, execute this code block

}

Gunakan loop for untuk melakukan iterasi pada semua item dalam daftar:

for (item in myList) {

// Execute this code block for each element of the list

}

Pengubah vararg memungkinkan Anda meneruskan sejumlah variabel argumen ke fungsi atau konstruktor.