Kotlin の Collection まとめ ～List編～ 

# はじめに

Java に比べた Kotlin のメリットとして、標準ライブラリがサポートしている Collection のメソッドがあります。
かゆいところに手が届くものがいろいろあって便利です。

今回、Listをベースに [Kotlin 公式](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/index.html) に記載されているプロパティ・メソッドを試してまとめてみました。

※ 全てを記載しているわけではありません。

## 宣言

最初にListの宣言をまとめておきます。
不変のリストは `listOf`
可変のリストは `mutableListOf`
で宣言します。

``` kotlin
val ms = mutableListOf("穂乃果", "ことり", "海未")
val first = listOf("花陽", "凛", "真姫")
val seitokai = listOf("絵里", "希")
ms.addAll(first)
ms.add("にこ")
ms.addAll(seitokai)

// エラー
// seitokai.add("にこ")

println(ms)
```

```:出力
[穂乃果, ことり, 海未, 花陽, 凛, 真姫, にこ, 絵里, 希]
```

ちなみに `null` を除いた List も生成できます。

```kotlin
val list = listOfNull("穂乃果", null, "ことり", null, "海未")

println(list)
```
```:出力
[穂乃果, ことり, 海未]
```

# parameters
## size
List のサイズを返します

```kotlin
val ms = listOf("穂乃果", "絵里", "ことり", "海未", "凛", "真姫", "希", "花陽", "にこ")
println(ms.size)
```
```:出力
9
```

# Function
List が持つ関数です

## contains
collection が引数の値を要素として持っていれば `true` を返します

```kotlin
val seconds = listOf("穂乃果", "ことり", "海未")
println(seconds.contains("穂乃果"))
```
```:出力
true
```

## containsAll
指定したcollectionが持つ要素を全て持っていれば `true` を返します。

```kotlin
val seconds = listOf("穂乃果", "ことり", "海未")
println(seconds.containsAll(listOf("穂乃果", "ことり")))
println(seconds.containsAll(listOf("穂乃果", "絵里")))
```
```:出力
true
false
```

## get
指定したインデックスの要素を取得します。
`get(index)` と `[index]` は同じです。

```kotlin
val ms = listOf("穂乃果", "絵里", "ことり", "海未", "凛", "真姫", "希", "花陽", "にこ")
println(ms.get(0))
println(ms[0])
```
```:出力
穂乃果
穂乃果
```

## indexOf, lastIndexOf
指定した要素がcollection内で初めて登場するインデックスを取得します。
該当するものがない場合は `-1` を返します。
`lastIndexOf` はcollectionの後ろから探査します。

```kotlin
val duplicate = listOf("穂乃果", "ことり", "ことり", "海未")
println(duplicate.indexOf("ことり"))
println(duplicate.indexOf("絵里"))
println(duplicate.lastIndexOf("ことり"))
```
```:出力
1
-1
2
```

## isEmpty
指定したcollectionが空なら `true` を返します。

```kotlin
val emptyList = listOf<String>()
val ms = listOf("穂乃果", "絵里", "ことり", "海未", "凛", "真姫", "希", "花陽", "にこ")
println(emptyList.isEmpty())
println(ms.isEmpty())
```
```:出力
true
false
```

## iterator, listIterator
list を iterator, listIterator に変換します。
引数にindexを指定すると、そこから開始します。

```kotlin
val ms = listOf("穂乃果", "絵里", "ことり", "海未", "凛", "真姫", "希", "花陽", "にこ")
val itr = ms.iterator()
val listItr = ms.listIterator(2)
println(itr.next())
println(listItr.previous())
```
```:出力
穂乃果
絵里
```

## subList
指定したlistを分割します。

```kotlin
val ms = listOf("穂乃果", "絵里", "ことり", "海未", "凛", "真姫", "希", "花陽", "にこ")
println(ms.subList(0, 3))
```
```:出力
[穂乃果, 絵里, ことり]
```

# Extension Properties

## indices
指定したlistの範囲(IntRange)を返します。

```kotlin
val ms = listOf("穂乃果", "絵里", "ことり", "海未", "凛", "真姫", "希", "花陽", "にこ")
println(ms.indices)
```
```:出力
0..8
```

## lastIndex
指定したlistの最後のインデックスを返します。

```
val ms = listOf("穂乃果", "絵里", "ことり", "海未", "凛", "真姫", "希", "花陽", "にこ")
println(ms.lastIndex)
```
```:出力
8
```

# Extension Functions
## all
指定した条件をlist内の全ての要素が満たす場合 `true` を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
println(numberList.all { it < 6 })
println(numberList.all { it < 5 })
```
```:出力
true
false
```

## any
指定した条件をlist内のいずれかの要素が満たす場合 `true` を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
println(numberList.any { it > 5 })
println(numberList.any { it > 4 })
```
```:出力
false
true
```

## asReversed
指定したlistを逆順にしたlistを返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
println(numberList.asReversed())
```
```:出力
[5, 4, 3, 2, 1]
```

## associate
listの各要素をMapに変換します。
`~By` は要素をkeyではなくvalueにします。
`~To` は引数に指定したMapに結果を入れます。
`~With` は要素をkey、ラムダ式内の結果をvalueにします。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
val associateMap = mutableMapOf<Int, Int>()
val associateByMap = mutableMapOf<Int, Int>()
val associateWithMap = mutableMapOf<Int, Int>()

println(numberList.associate { it to it * 10 })
println(numberList.associateBy { it * 10 })
println(numberList.associateTo(associateMap) { it to it * 100 })
println(numberList.associateByTo(associateByMap) { it * 100 })
println(numberList.associateWith { it * 1000 })
println(numberList.associateWithTo(associateWithMap) { it * 1000 })
```
```:出力
{1=10, 2=20, 3=30, 4=40, 5=50}
{10=1, 20=2, 30=3, 40=4, 50=5}
{1=100, 2=200, 3=300, 4=400, 5=500}
{100=1, 200=2, 300=3, 400=4, 500=5}
{1=1000, 2=2000, 3=3000, 4=4000, 5=5000}
{1=1000, 2=2000, 3=3000, 4=4000, 5=5000}
```

## binarySearch, binarySearchBy
バイナリサーチで指定した要素のインデックスを返します。
指定した要素が存在しない場合、負の数を返します。
listはソートされている必要があり、ソートされていないと正しい値を返しません。
引数で探査する始点・終点・比較方法などを設定できます。
`binarySearchBy` は `selector` で要素を変換したうえで探査します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.binarySearch(2))
println(numberList.binarySearch(6))
println(numberList.binarySearch(element = 2, fromIndex = 0, toIndex = 3))
println(numberList.binarySearch(element = 2, comparator = Comparator { a, b -> a - b }))
println(numberList.binarySearchBy(2, selector = { it }))
```
```:出力
1
-6
1
1
1
```

## chunked
listを引数で指定した数ごとにグループ化します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
println(numberList.chunked(2))
```
```:出力
[[1, 2], [3, 4], [5]]
```

## component
指定したインデックスの要素を取得します。
`get` か `[]` でいい。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.component1())
println(numberList.component2())
```
```:出力
1
2
```

## contains, containsAll
listが指定した要素を含んでいれば `true` を返します。
`containsAll` は引数にlistを指定します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.contains(2))
println(numberList.contains(6))
println(numberList.containsAll(listOf(1, 3, 4, 5, 2)))
```
```:出力
true
false
true
```

## count
指定した条件に一致する要素がいくつあるかを返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
println(numberList.count { it > 3 })
```
```:出力
2
```

## distinct, distinctBy
要素の重複を除外したlistを返します。
`distinctBy` は指定した条件を重複判定に用います。

```kotlin
val distinctList = listOf(1, 1, 2, 3, 4, 4)
println(distinctList.distinct())
println(distinctList.distinctBy { it > 2 })
```
```:出力
[1, 2, 3, 4]
[1, 3]
```

## drop, dropLast, dropWhile, dropLastWhile
指定した数の分、要素を除外したlistを返します。
`dropLast` は後ろから除外します。
`dropWhile` は指定した条件を満たす間除外します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.drop(2))
println(numberList.dropLast(2))
println(numberList.dropWhile { it < 2 })
println(numberList.dropLastWhile { it > 2 })
```
```:出力
[3, 4, 5]
[1, 2, 3]
[2, 3, 4, 5]
[1, 2]
```

## elementAt, elementAtOrElse, elementAtOrNull
指定したインデックスの要素を取得します。
`elementAt` でインデックスがlistのサイズを超えた場合は `IndexOutOfBoundsException` が発生します。
`elementAtOrElse` は指定したインデックスが範囲外だった場合の返却値をラムダ式で定義できます。
`elementAtOrNull` は指定したインデックスが範囲外だった場合 `null` を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.elementAt(2))
println(numberList.elementAtOrElse(6) { 8 })
println(numberList.elementAtOrNull(6))
```
```:出力
3
8
null
```

## filter系

### filter
指定した条件に合致する要素のみ残したlistを返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.filter { it > 3 })
```
```:出力
[4, 5]
```

### filterIndexed, filterIndexedTo
インデックス付きのfilter
`filterIndexedTo` は引数に指定したlistに結果を入れます。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
val filterList = mutableListOf<Int>()

println(numberList.filterIndexed { idx, num -> num > 2 && idx > 3 })

numberList.filterIndexedTo(filterList) { idx, num -> num > 2 && idx > 3 }
println(filterList)
```
```:出力
[5]
[5]
```

### filterIsInstance, filterIsInstanceTo
指定する条件がクラスになったfilterです。

```kotlin
val instanceList = listOf(1, "穂乃果", 3.5, true)
val filterList = mutableListOf<Int>()

println(instanceList.filterIsInstance(String::class.java))

instanceList.filterIsInstanceTo(filterList, Int::class.java)
println(filterList)
```
```:出力
[穂乃果]
[5]
```

### filterNot, filterNotNull
指定した条件に合致**しない**要素のみ残したlistを返します。
`filterNotNull` は `null` を除外します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
val nullList = listOf(1, null, 3, null)

println(numberList.filterNot { it > 3 })
println(nullList.filterNotNull())
```
```:出力
[1, 2, 3]
[1, 3]
```

## find, findLast
指定した条件に合致する最初の要素を返します。
条件に合致する要素がない場合は `null` を返します。
`findLast` は後ろから要素を探索します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.find { it > 2 })
println(numberList.find { it > 5 })
println(numberList.findLast { it > 2 })
```
```:出力
3
null
5
```

## first, firstOrNull
最初の要素を返します。
ラムダ式を指定した場合は条件に一致する最初の要素を返します。
条件に合致する要素がない場合 `NoSuchElementException` が発生します。
firstOrNull は条件に合致する要素がない場合 `null` を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.first())
println(numberList.first { it > 2 })
println(numberList.firstOrNull { it > 5 })
```
```:出力
1
3
null
```

## flatMap, flatten
階層になっているlistを平坦にします。
`flatMap` はラムダ式で要素の操作ができます。
`flatten` は単に平坦にします。

```kotlin
val flatMapList = listOf(listOf(1, 2, 3), listOf(4, 5, 6))
println(flatMapList.flatMap { it.map { num -> num * 10 } })
println(flatMapList.flatten())
```
```:出力
[10, 20, 30, 40, 50, 60]
[1, 2, 3, 4, 5, 6]
```

## fold, foldRight
引数で指定した値を要素の先頭につけた上で、すべて連結して返します。
`foldRight` はlistの逆から要素を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.fold("X") { initial, value -> initial + value })
println(numberList.foldRight("X") { value, initial -> initial + value })
```
```:出力
X12345
X54321
```

## forEach, forEachIndexed 
listをループします。
ラムダ式内で各要素に対する操作が行えます。
`forEachIndexed` はインデックス付きでループします。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

numberList.forEach { print("${it} ") }
numberList.forEachIndexed { idx, value -> print("${idx}: ${value} ") }
```
```:出力
1 2 3 4 5
0: 1 1: 2 2: 3 3: 4 4: 5
```

## getOrElse, getOrNull
指定したインデックスの要素を取得します。
`getOrElse` はインデックスがlistの範囲外だった際の値を指定できます。
`getOrNull` はインデックスがlistの範囲外だった際に `null` を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.getOrElse(6) { 8 })
println(numberList.getOrNull(6))
```
```:出力
8
null
```

## groupBy
要素をグループ化します。
第一引数でグループ化するkeyを、第二引数でグループ化した後のvalueを指定します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.groupBy({ if (it % 2 == 0) "偶数" else "奇数" }, { it + 2 }))
```
```:出力
{奇数=[3, 5, 7], 偶数=[4, 6]}
```

## groupingBy
指定した関数オブジェクトで求められる値をkeyとするMapを求めるためのインターフェースを用意します。
`eachCount()` はkeyで指定した要素がいくつあるかを算出します。

```kotlin
val distinctList = listOf(1, 1, 2, 3, 4, 4)

println(distinctList.groupingBy { it }.eachCount())
```
```:出力
{1=2, 2=1, 3=1, 4=2}
```

## ifEmpty
配列が空の場合にラムダ式で指定した値を返します。
空でなければlistをそのまま返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
val emptyList = listOf<String>()

println(numberList.ifEmpty { 5 })
println(emptyList.ifEmpty { 5 })
```
```:出力
[1, 2, 3, 4, 5]
5
```

## indexOf, indexOfFirst, indexOfLast
指定した値に合致する要素のインデックスを返します。
合致する要素がなければ `-1` を返します。
`indexOfFirst` はラムダ式で条件を指定可能。
`indexOfLast` はlistの後ろから探索。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.indexOf(6))
println(numberList.indexOfFirst { it % 2 == 0 })
println(numberList.indexOfLast { it % 2 == 0 })
```
```:出力
-1
1
3
```

## intersect
引数に指定したものと重複する要素を抽出します。
結果は `Set` になります。

```kotlin
val intersectList = listOf(1, 4)
println(numberList.intersect(intersectList))
```
```:出力
[1, 4]
```

## isNotEmpty, isNullOrEmpty
listが空ではないか、nullもしくは空か判定します。

```kotlin
val emptyList = listOf<String>()
val nullObj: List<String>? = null
println(emptyList.isNotEmpty())
println(nullObj.isNullOrEmpty())
```
```:出力
false
true
```

## joinTo, joinToString
listの各要素を指定した条件で連結した文字列を返します。
区切り文字だけではなく、prefixなどいろいろな要素が指定できます。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.joinTo(StringBuilder()))
println(numberList.joinToString(
	separator = ".",
	prefix = "{",
	postfix = "}",
	limit = 3,
	truncated = "~",
	transform = { "${it * 2}" }
))
```
```:出力
1, 2, 3, 4, 5
{2.4.6.~}
```

## last, lastOrNull
listの最後の値を取得します。
`lastIndexOf` はlistが空の場合に`null`を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
val emptyList = listOf<Int>()

println(numberList.last())
println(numberList.lastOrNull())
println(emptyList.lastOrNull())
```
```:出力
5
5
null
```

## lastIndexOf
指定した値が最初に登場するインデックスを後ろから探査します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.lastIndexOf(4))
```
```:出力
3
```

## map, mapIndexed, mapNotNull
各要素に対して特定の操作を行い、その返却値に値を変えたlistを返します。
`mapIndexed` はインデックス付きです。
`mapNotNull` はラムダ式内の結果がnullだった場合はそれを除外します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
val nullList = listOf(1, null, 3, null)

println(numberList.map { it * 2 })
println(numberList.mapIndexed { idx, value -> idx + value })
println(nullList.mapNotNull { it?.toString() })
```
```:出力
[2, 4, 6, 8, 10]
[1, 3, 5, 7, 9]
[1, 3]
```

## maxBy, minBy, maxWith, minWith
ラムダ式で指定した条件で各要素を判定したときの最大・最小の値を返します。
`~With` は引数に `Comparator` を取ることで比較方法を指定できる。

```kotlin
val stringList = listOf("a", "bb", "ccc")
val numberList = listOf(1, 2, 3, 4, 5)

println(stringList.maxBy { it.length })
println(stringList.minBy { it.length })
println(numberList.maxWith(Comparator { a, b -> b - a }))
println(numberList.minWith(Comparator { a, b -> b - a }))
```
```:出力
ccc
a
1
5
```

## minus
引数で指定した要素を差し引いたlistを返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.minus(2))
println(numberList.minus(listOf(1, 3)))
```
```:出力
[1, 3, 4, 5]
[2, 4, 5]
```

## none
ラムダ式に指定した条件の要素がなければ `true` を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.none { it > 5 })
```
```:出力
true
```

##partition
各要素がラムダ式で指定した条件に対してtrueのものとfalseのものに分割した`Pair`を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.partition { it % 2 == 0 })
```
```:出力
([2, 4], [1, 3, 5])
```

## plus
引数で指定した要素を追加したlistを返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.plus(2))
println(numberList.plus(listOf(1, 3)))
```
```:出力
[1, 2, 3, 4, 5, 2]
[1, 2, 3, 4, 5, 1, 3]
```

## random
listからランダムに一つの要素を取り出します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.random())
```
```:出力
1
```

## reduce
ラムダ式に指定した処理を重ねて処理をします。
第一引数には最初はlistの最初の要素、以降はラムダ式で処理した直前の値が入ります。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.reduce({ acc, value ->
	print("${acc} * ${value} = ")
	acc * value
}))
```
```:出力
1 * 2 = 2 * 3 = 6 * 4 = 24 * 5 = 120
```

## requireNoNulls
listに`null`がないか確認し、なければlistを返します。
`null` がある場合は `IllegalArgumentException` が発生します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.requireNoNulls())
```
```:出力
[1, 2, 3, 4, 5]
```

## reversed
listを逆順にしたlistを返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.reversed())
```
```:出力
[5, 4, 3, 2, 1]
```

## shuffled
listの各要素をシャッフルしたlistを返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.shuffled())
```
```:出力
[1, 3, 5, 4, 2]
```

## single, singleOrNull
listに存在する唯一の要素を取得します。
ラムダ式で条件も指定可能です。
該当する要素が存在しない、もしくは複数存在する場合は`IllegalArgumentException`が発生します。
`singleOrNull`はエラーの代わりに`null`を返します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.single { it == 2 })
println(numberList.singleOrNull())
```
```:出力
2
null
```

## slice
引数に指定した範囲でlistを分割します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.slice(1..2))
```
```:出力
[2, 3]
```

## sorted, sortedDescending, sortBy, sortedWith
listをソートします。
`sortedDescending` は降順。
`sortBy` はソート方法をラムダ式で調整。
`sortedWith` はソート条件を `Comparator` で指定。

```kotlin
val sortList = listOf(1, 5, 4, 3, 2)

println(sortList.sorted())
println(sortList.sortedDescending())
println(sortList.sortedBy { it * -1 })
println(sortList.sortedWith(Comparator { a, b -> a - b }))
```
```:出力
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
```

## subtract
指定したcollectionに存在しない要素だけを抽出して`Set`で返します。
重複は除去されます。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
val subtractList = listOf(2, 3)

println(numberList.subtract(subtractList))
```
```:出力
[1, 4, 5]
```

## sum, sumBy
要素の合計を返します。
`sumBy` はラムダ式で値を変更できます。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.sum())
println(numberList.sumBy { it * 10 })
```
```:出力
15
150
```

## take, takeLast, takeWhile
指定した数だけlistから要素を取得します。
`takeLast` はlistの後ろから取得します。
`takeWhile` は指定した条件がtrueの間取得します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.take(2))
println(numberList.takeLast(2))
println(numberList.takeWhile { it < 4 })
```
```:出力
[1, 2]
[4, 5]
[1, 2, 3]
```

## union
2つのlistの要素を合計して`Set`を返します。
重複は除去されます。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)
val unionList = listOf(3, 4, 5, 6, 7)

println(numberList.union(unionList))
```
```:出力
[1, 2, 3, 4, 5, 6, 7]
```

## unzip
`Pair` のlistのkeyだけ、valueだけをまとめたlistの`Pair`を返します。

```kotlin
val pairList = listOf(Pair(1, "one"), Pair(2, "two"), Pair(3, "three"))

println(pairList.unzip())
```
```:出力
([1, 2, 3], [one, two, three])
```

## windowed
listを指定したサイズ・間隔で分割したlistにします。
`partialWindows` が `true` の場合は`size`に満たないはみ出した要素も出力します。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.windowed(size = 2, step = 2, partialWindows = true))
println(numberList.windowed(size = 2, step = 2))
```
```:出力
[[1, 2], [3, 4], [5]]
[[1, 2], [3, 4]]
```

## withIndex
listをindexつきにします。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

numberList.withIndex().forEach { print("${it.index} : ${it.value}, ") }
```
```:出力
0 : 1, 1 : 2, 2 : 3, 3 : 4, 4 : 5, 
```

## zip
listどうしの各要素を`Pair`にします。
不足する要素は無視されます。
第二引数にラムダ式を指定することで`Pair`以外に変換できます。

```kotlin
val zip1 = listOf(1, 2, 3, 4)
val zip2 = listOf("one", "two", "three")

println(zip1.zip(zip2))
println(zip1.zip(zip2, { a, b -> "${a} = ${b}" }))
```
```:出力
[(1, one), (2, two), (3, three)]
[1 = one, 2 = two, 3 = three]
```

## zipWithNext
listの各要素を、次の要素との`Pair`にします。
ラムダ式で条件を指定することで`Pair`以外に変換できます。

```kotlin
val numberList = listOf(1, 2, 3, 4, 5)

println(numberList.zipWithNext())
println(numberList.zipWithNext { a, b -> a + b })
```
```:出力
[(1, 2), (2, 3), (3, 4), (4, 5)]
[3, 5, 7, 9]
```