Gambaran keseluruhan API Koleksi Kotlin

1. Gambaran keseluruhan

Dalam tutorial ringkas ini, kami akan memperkenalkan Koleksi API Kotlin, dan kami akan membincangkan pelbagai jenis koleksi di Kotlin dan beberapa operasi biasa pada koleksi.

2. Koleksi vs Koleksi Mutable

Pertama, mari kita lihat pelbagai jenis koleksi di Kotlin. Kami akan melihat bagaimana memulakan jenis koleksi asas.

Antara muka Koleksi menyokong kaedah baca sahaja manakala MutableCollection menyokong kaedah membaca / menulis.

2.1. Senaraikan

Kita boleh membuat Senarai hanya baca mudah menggunakan kaedah listOf () dan membaca-menulis MutableList menggunakan mutableListOf () :

val theList = listOf("one", "two", "three") val theMutableList = mutableListOf("one", "two", "three")

2.2. Tetapkan

Begitu juga kita dapat membuat Set baca sahaja menggunakan kaedah setOf () dan baca-tulis MutableSet menggunakan mutableSetOf () :

val theSet = setOf("one", "two", "three") val theMutableSet = mutableSetOf("one", "two", "three")

2.3. Peta

Kita juga boleh membuat Peta baca sahaja menggunakan kaedah mapOf () dan membaca-menulis MutableMap menggunakan mutableMapOf () :

val theMap = mapOf(1 to "one", 2 to "two", 3 to "three") val theMutableMap = mutableMapOf(1 to "one", 2 to "two", 3 to "three")

3. Pengendali Berguna

Kotlin's Collections API jauh lebih kaya daripada yang dapat kita temukan di Java - ia dilengkapi dengan sekumpulan operator yang terlalu banyak.

3.1. The " di" Operator

Kita dapat menggunakan ungkapan " x dalam koleksi " yang dapat diterjemahkan ke koleksi. Mengandungi (x) :

@Test fun whenSearchForExistingItem_thenFound () { val theList = listOf("one", "two", "three") assertTrue("two" in theList) }

3.2. The "+" Operator

Kami dapat elemen atau keseluruhan koleksi ke yang lain menggunakan operator "+":

@Test fun whenJoinTwoCollections_thenSuccess () { val firstList = listOf("one", "two", "three") val secondList = listOf("four", "five", "six") val resultList = firstList + secondList assertEquals(6, resultList.size) assertTrue(resultList.contains("two")) assertTrue(resultList.contains("five")) }

3.3. The "-" Operator

Begitu juga, kita boleh membuang elemen atau beberapa elemen menggunakan operator "-":

@Test fun whenExcludeItems_thenRemoved () { val firstList = listOf("one", "two", "three") val secondList = listOf("one", "three") val resultList = firstList - secondList assertEquals(1, resultList.size) assertTrue(resultList.contains("two")) }

4. Kaedah Lain

Akhirnya, kami akan meneroka beberapa kaedah umum untuk pengumpulan. Di Jawa, jika kita ingin memanfaatkan metode lanjutan, kita harus menggunakan Stream API.

Di Kotlin, kita dapat menemui kaedah serupa yang terdapat di Koleksi API.

4.1. Menghiris

Kita dapat memperoleh sub senarai dari Senarai tertentu :

@Test fun whenSliceCollection_thenSuccess () { val theList = listOf("one", "two", "three") val resultList = theList.slice(1..2) assertEquals(2, resultList.size) assertTrue(resultList.contains("two")) }

4.2. Mengeluarkan

Kita boleh membuang semua nol dari Senarai dengan mudah

@Test fun whenFilterNullValues_thenSuccess () { val theList = listOf("one", null, "two", null, "three") val resultList = theList.filterNotNull() assertEquals(3, resultList.size) }

4.3. Penapisan

Kami dapat menapis item koleksi dengan mudah menggunakan filter (), yang berfungsi sama dengan kaedah filter () dari Java Stream API:

@Test fun whenFilterNonPositiveValues_thenSuccess () { val theList = listOf(1, 2, -3, -4, 5, -6) val resultList = theList.filter{ it > 0} assertEquals(3, resultList.size) assertTrue(resultList.contains(1)) assertFalse(resultList.contains(-4)) }

4.4. Menjatuhkan

Kami boleh menjatuhkan item N pertama:

@Test fun whenDropFirstItems_thenRemoved () { val theList = listOf("one", "two", "three", "four") val resultList = theList.drop(2) assertEquals(2, resultList.size) assertFalse(resultList.contains("one")) assertFalse(resultList.contains("two")) }

Kami dapat menjatuhkan beberapa item pertama jika memenuhi syarat yang diberikan:

@Test fun whenDropFirstItemsBasedOnCondition_thenRemoved () { val theList = listOf("one", "two", "three", "four") val resultList = theList.dropWhile{ it.length < 4 } assertEquals(2, resultList.size) assertFalse(resultList.contains("one")) assertFalse(resultList.contains("two")) }

4.5. Pengumpulan

Kita boleh mengumpulkan elemen:

@Test fun whenGroupItems_thenSuccess () { val theList = listOf(1, 2, 3, 4, 5, 6) val resultMap = theList.groupBy{ it % 3} assertEquals(3, resultMap.size) assertTrue(resultMap[1]!!.contains(1)) assertTrue(resultMap[2]!!.contains(5)) }

4.6. Pemetaan

Kami dapat memetakan semua elemen menggunakan fungsi yang disediakan:

@Test fun whenApplyFunctionToAllItems_thenSuccess () { val theList = listOf(1, 2, 3, 4, 5, 6) val resultList = theList.map{ it * it } assertEquals(4, resultList[1]) assertEquals(9, resultList[2]) }

Kita boleh menggunakan flatMap () untuk meratakan koleksi bersarang. Di sini, kami menukar Strings ke L ist dan mengelakkan berakhir dengan List :

@Test fun whenApplyMultiOutputFunctionToAllItems_thenSuccess () { val theList = listOf("John", "Tom") val resultList = theList.flatMap{ it.toLowerCase().toList() } assertEquals(7, resultList.size) }

4.7. Pengurangan

Kami dapat melakukan operasi lipatan / pengurangan :

@Test fun whenApplyFunctionToAllItemsWithStartingValue_thenSuccess () { val theList = listOf(1, 2, 3, 4, 5, 6) val finalResult = theList.fold(0, {acc, i -> acc + (i * i)}) assertEquals(91, finalResult) }

4.8. Chunking

Untuk memecahkan koleksi menjadi potongan ukuran tertentu, kita dapat menggunakan kaedah chunked () :

@Test fun whenApplyingChunked_thenShouldBreakTheCollection() { val theList = listOf(1, 2, 3, 4, 5) val chunked = theList.chunked(2) assertThat(chunked.size).isEqualTo(3) assertThat(chunked.first()).contains(1, 2) assertThat(chunked[1]).contains(3, 4) assertThat(chunked.last()).contains(5) }

Since the collection has five elements, the chunked(2) method call returns two collections with two elements each and one single-element collection.

It's also possible to map each chunk to something else after breaking up the collection:

@Test fun whenApplyingChunkedWithTransformation_thenShouldBreakTheCollection() { val theList = listOf(1, 2, 3, 4, 5) val chunked = theList.chunked(3) { it.joinToString(", ") } assertThat(chunked.size).isEqualTo(2) assertThat(chunked.first()).isEqualTo("1, 2, 3") assertThat(chunked.last()).isEqualTo("4, 5") }

After creating chunks of size 3, we convert each chunk to a comma-separated string.

4.9. Windowing

The windowed() function returns a list of element ranges by moving a sliding window of a given size over a collection of elements.

In order to better understand this, let's see how windowed(3) works on a collection of 6 elements:

At first, the window size is 3, therefore the first list would contain 1, 2, and 3. Then the sliding window moves one element further:

Tetingkap gelongsor bergerak ke hadapan sehingga gagal membuat senarai ukuran lain yang diberikan:

Urutan peralihan ini menampakkan diri dalam kod Kotlin sebagai:

@Test fun whenApplyingWindowed_thenShouldCreateSlidingWindowsOfElements() { val theList = (1..6).toList() val windowed = theList.windowed(3) assertThat(windowed.size).isEqualTo(4) assertThat(windowed.first()).contains(1, 2, 3) assertThat(windowed[1]).contains(2, 3, 4) assertThat(windowed[2]).contains(3, 4, 5) assertThat(windowed.last()).contains(4, 5, 6) }

Secara lalai, tetingkap gelangsar bergerak selangkah lebih jauh setiap kali. Kita tentu saja dapat mengubahnya dengan meneruskan nilai langkah khusus:

@Test fun whenApplyingWindowedWithTwoSteps_thenShouldCreateSlidingWindowsOfElements() { val theList = (1..6).toList() val windowed = theList.windowed(size = 3, step = 2) assertThat(windowed.size).isEqualTo(2) assertThat(windowed.first()).contains(1, 2, 3) assertThat(windowed.last()).contains(3, 4, 5) }

Fungsi windowed () , secara lalai, selalu dan hanya membuat julat ukuran yang diberikan. Untuk mengubahnya, kita dapat menetapkan parameter partialWindows ke true :

@Test fun whenApplyingPartialWindowedWithTwoSteps_thenShouldCreateSlidingWindowsOfElements() { val theList = (1..6).toList() val windowed = theList.windowed(size = 3, step = 2, partialWindows = true) assertThat(windowed.size).isEqualTo(3) assertThat(windowed.first()).contains(1, 2, 3) assertThat(windowed[1]).contains(3, 4, 5) assertThat(windowed.last()).contains(5, 6) }

Mirip dengan fungsi chunked () , mungkin untuk memetakan setiap julat ke sesuatu yang lain:

@Test fun whenApplyingTransformingWindows_thenShouldCreateSlidingWindowsOfElements() { val theList = (1..6).toList() val windowed = theList.windowed(size = 3, step = 2, partialWindows = true) { it.joinToString(", ") } assertThat(windowed.size).isEqualTo(3) assertThat(windowed.first()).isEqualTo("1, 2, 3") assertThat(windowed[1]).isEqualTo("3, 4, 5") assertThat(windowed.last()).isEqualTo("5, 6") }

5. Kesimpulan

Kami meneroka API Koleksi Kotlin dan beberapa kaedah yang paling menarik.

Dan, seperti biasa, kod sumber lengkap boleh didapati di GitHub.