Kotlin: foreachで要素とインデックスを一緒に使う

Kotlin: forEachで要素とインデックスを一緒に使う – コレクション処理の強力なテクニック

はじめに

ソフトウェア開発において、コレクション（リスト、セット、配列など）の要素を一つずつ処理することは非常に一般的です。例えば、リストの各要素を表示したり、条件を満たす要素だけを抽出したり、各要素に対して計算を行ったりと、様々なシナリオが考えられます。このような繰り返し処理を行うための構文は、多くのプログラミング言語に用意されています。

Kotlinにおいても、コレクションの要素をイテレーション（反復処理）するための多様な手段が提供されています。古典的な for ループはもちろんのこと、関数型プログラミングのパラダイムを取り入れた forEach や、遅延評価が可能な Sequence を用いた処理など、目的に応じて最適な方法を選択できます。

中でも forEach は、簡潔な構文でコレクションの要素を順に処理できるため、Kotlinのコードで頻繁に利用されます。特に、各要素に対して何らかの副作用（例えば出力や状態変更）を伴う処理を行う場合に便利です。しかし、単純に要素だけが必要な場合だけでなく、その要素がコレクションの中で「何番目」にあるのか、つまり「インデックス」の情報も同時に必要になる場面も少なくありません。

この記事では、Kotlinで forEach (またはそれに類する方法) を使用して、コレクションの要素だけでなく、そのインデックスも一緒に取得・利用する方法について、様々な角度から詳細に解説します。複数のアプローチが存在するため、それぞれの方法の構文、利点、欠点、そしてどのような状況でどの方法を選ぶべきかについて深く掘り下げていきます。コレクション処理をより効率的かつKotlinらしい方法で行いたいと考えている方にとって、この記事が役立つ情報源となることを願っています。

コレクションの基本的なイテレーション方法

まず、Kotlinでコレクションをイテレーションする基本的な方法をおさらいしましょう。

1. `for` ループ

最も伝統的で柔軟なイテレーション方法です。インデックスを使う場合と使わない場合の両方で利用できます。

要素のみが必要な場合:

kotlin val fruits = listOf("Apple", "Banana", "Cherry") for (fruit in fruits) { println(fruit) } // 出力: // Apple // Banana // Cherry

インデックスと要素の両方が必要な場合 (インデックス範囲を使用):

kotlin val fruits = listOf("Apple", "Banana", "Cherry") for (i in 0 until fruits.size) { println("Index $i: ${fruits[i]}") } // 出力: // Index 0: Apple // Index 1: Banana // Index 2: Cherry

インデックスと要素の両方が必要な場合 (indices プロパティを使用):

indices プロパティは、コレクションの有効なインデックス範囲（0 から size-1 まで）を表す IntRange を返します。

kotlin val fruits = listOf("Apple", "Banana", "Cherry") for (i in fruits.indices) { println("Index $i: ${fruits[i]}") } // 出力: // Index 0: Apple // Index 1: Banana // Index 2: Cherry

for ループの最大の利点は、break や continue といった制御フローキーワードを直接使用できる点です。特定の条件でループを中断したり、現在のイテレーションをスキップしたりする必要がある場合に非常に強力です。

2. `while` / `do-while` ループ

条件が満たされている間、繰り返し処理を行います。コレクションのイテレーションに直接使うことは少ないですが、イテレータと組み合わせて使うことは可能です。

kotlin val numbers = mutableListOf(1, 2, 3, 4, 5) val iterator = numbers.iterator() while (iterator.hasNext()) { val number = iterator.next() println(number) } // 出力: // 1 // 2 // 3 // 4 // 5

この方法は for ループや forEach に比べて冗長になるため、通常はコレクションの単純なイテレーションには使用されません。

3. `forEach` 拡張関数

Kotlinの標準ライブラリで提供される、コレクションに対する拡張関数です。各要素に対してラムダ式を実行します。簡潔で可読性が高く、関数型プログラミングのスタイルに適しています。

kotlin val fruits = listOf("Apple", "Banana", "Cherry") fruits.forEach { fruit -> println(fruit) } // あるいは、ラムダ式の引数が一つの場合は 'it' で参照可能 fruits.forEach { println(it) } // 出力: // Apple // Banana // Cherry

forEach は内部的にコレクションの iterator() を使用して要素を順に処理します。ただし、forEach のラムダ式内では、通常の for ループのように break や continue を直接使うことはできません（代替手段については後述します）。

`forEach` でインデックスを使う方法

さて、ここからが本題です。forEach 自体は要素のみをラムダ式に渡しますが、インデックスも同時に利用したい場合はどうすれば良いでしょうか？ Kotlinにはいくつかの方法が用意されています。

方法1: `forEachIndexed` の使用

最も直接的で推奨される方法の一つが、forEachIndexed という拡張関数を使用することです。これは forEach と非常によく似ていますが、ラムダ式が要素だけでなくそのインデックスも引数として受け取ります。

構文:

kotlin collection.forEachIndexed { index, element -> // index を使った処理 // element を使った処理 }

ラムダ式の最初の引数がインデックス（デフォルトで index という名前が推奨されます）、二番目の引数が要素（デフォルトで value や element という名前が推奨されます）となります。これらの引数名は自由に指定できます。

具体的な使用例 (List):

“`kotlin
val colors = listOf(“Red”, “Green”, “Blue”, “Yellow”)

colors.forEachIndexed { index, color ->
println(“Color at index $index is $color”)
}

// 出力:
// Color at index 0 is Red
// Color at index 1 is Green
// Color at index 2 is Blue
// Color at index 3 is Yellow
“`

具体的な使用例 (Array):

Array に対しても forEachIndexed は利用可能です。

“`kotlin
val primeNumbers = arrayOf(2, 3, 5, 7, 11)

primeNumbers.forEachIndexed { i, num ->
println(“Prime number at position $i: $num”)
}

// 出力:
// Prime number at position 0: 2
// Prime number at position 1: 3
// Prime number at position 2: 5
// Prime number at position 3: 7
// Prime number at position 4: 11
“`

forEachIndexed の利点:

明確さ: コードを見れば、インデックスと要素の両方を使っていることがすぐにわかります。
簡潔さ: for ループでインデックス範囲を指定する方法に比べて、記述量が少なく済みます。
Kotlinらしい書き方: コレクションに対する拡張関数として提供されており、Kotlinのイディオマティックなスタイルに合致します。

forEachIndexed の注意点:

forEach と同様に、forEachIndexed のラムダ式内では break や continue を直接使用できません。特定の条件でループ全体を中断したい場合や、現在の要素の処理をスキップしたい場合は、別の方法を検討する必要があります（これについても後述します）。

forEachIndexed の内部的な仕組み (簡潔に):

forEachIndexed は、内部的にはコレクションのイテレータを使用しながら、同時にインデックスをカウントアップしていく処理を行っています。概念的には、以下のような処理をラップしていると考えると理解しやすいでしょう。

“`kotlin
// イメージ (実際のforEachIndexedの実装ではありません)
fun Iterable.manualForEachIndexed(action: (Int, T) -> Unit) {
var index = 0
for (element in this) { // または iterator() を使用
action(index, element)
index++
}
}

// 使用例 (上記イメージの関数を使用)
val letters = listOf(‘a’, ‘b’, ‘c’)
letters.manualForEachIndexed { index, letter ->
println(“$index: $letter”)
}
“`

実際の forEachIndexed はより最適化されていますが、基本的な考え方は、要素を順に取得しつつ、0から始まるカウンターをインクリメントしてインデックスとして提供する、というものです。

方法2: `withIndex()` を使用した `forEach`

もう一つの強力なアプローチは、コレクションに withIndex() 拡張関数を適用してから forEach を使用する方法です。

withIndex() とは何か:

withIndex() は、Iterable<T> (リスト、セットなど) や Array<T> に対して呼び出すことができる拡張関数です。この関数は、元のコレクションの要素を、それぞれのインデックスとペアにした IndexedValue<T> オブジェクトのシーケンス (Sequence<IndexedValue<T>>) またはリスト (List<IndexedValue<T>>) に変換して返します。

IndexedValue<T> クラス:

IndexedValue<T> はKotlin標準ライブラリで定義されているデータクラスです。非常にシンプルで、以下の二つのプロパティを持ちます。

index: Int – 要素のインデックス
value: T – 要素自体

withIndex() を forEach と組み合わせる構文:

kotlin collection.withIndex().forEach { indexedValue -> val index = indexedValue.index val element = indexedValue.value // index と element を使った処理 }

または、構造分解宣言 (Destructuring Declaration) を使用して、IndexedValue オブジェクトから直接インデックスと要素を取り出すこともできます。この書き方は forEachIndexed と似ていて、よりKotlinらしいスタイルです。

kotlin collection.withIndex().forEach { (index, element) -> // index を使った処理 // element を使った処理 }
構造分解宣言を使った形式は、forEachIndexed { index, element -> ... } と構文上非常に似ていますが、内部的なアプローチが異なります。

具体的な使用例 (List):

“`kotlin
val cities = listOf(“Tokyo”, “Osaka”, “Kyoto”)

cities.withIndex().forEach { (index, city) ->
println(“City #$index: $city”)
}

// 出力:
// City #0: Tokyo
// City #1: Osaka
// City #2: Kyoto
“`

具体的な使用例 (Set):

Set は通常、要素の順序を保証しませんが、withIndex() を使用すると、イテレーションされる順序でのインデックスを取得できます。ただし、この順序はセットの実装（例: LinkedHashSet は挿入順を保持）や操作によって変わる可能性があるため、セットでインデックスを使う場合は注意が必要です。

“`kotlin
val uniqueLetters = setOf(‘x’, ‘y’, ‘z’)

uniqueLetters.withIndex().forEach { (index, letter) ->
println(“Item $index: $letter”)
}

// 出力例 (LinkedHashSet の場合):
// Item 0: x
// Item 1: y
// Item 2: z
// ※ Set の種類によっては出力順が異なる場合があります。
“`

具体的な使用例 (Map):

Map はキーと値のペアのコレクション (Map.Entry) です。Map.entries ビューに対して withIndex() を適用することで、マップのエントリをイテレーションする際のインデックスを取得できます。

“`kotlin
val map = mapOf(“a” to 1, “b” to 2, “c” to 3)

map.entries.withIndex().forEach { (index, entry) ->
println(“Entry $index: Key = ${entry.key}, Value = ${entry.value}”)
}

// 出力:
// Entry 0: Key = a, Value = 1
// Entry 1: Key = b, Value = 2
// Entry 2: Key = c, Value = 3
“`
マップのエントリに対して構造分解宣言を使うと、キーと値を直接取り出せます。

kotlin map.entries.withIndex().forEach { (index, (key, value)) -> println("Entry $index: Key = $key, Value = $value") } // 出力は上記と同じ

withIndex().forEach { ... } の利点:

柔軟性: withIndex() は forEach だけでなく、map, filter, reduce などの他のコレクション操作と組み合わせて使用できます。例えば、インデックスが偶数の要素だけをフィルタリングしたり、インデックス情報を含んだ新しいリストを作成したりする場合に便利です。
“`kotlin
val numbers = listOf(10, 20, 30, 40, 50)
val indexedPairs = numbers.withIndex()
.filter { (index, _) -> index % 2 == 0 } // インデックスが偶数のものだけフィルタ
.map { (index, value) -> “Index $index, Value $value” } // 文字列に変換
println(indexedPairs) // 出力: [Index 0, Value 10, Index 2, Value 30, Index 4, Value 50]

numbers.withIndex().forEach { (index, value) ->
// forEach でフィルタリング相当の処理をif文で行うことも可能
if (index % 2 == 0) {
println(“Index $index, Value $value”)
}
}
// 出力:
// Index 0, Value 10
// Index 2, Value 30
// Index 4, Value 50
`` * **IndexedValueオブジェクト:** インデックスと要素がペアになったIndexedValue` オブジェクトとして扱えるため、このペアを別の関数に渡したり、リストに収集したりといった操作が容易になります。

withIndex().forEach { ... } の注意点:

forEachIndexed と同様に、ラムダ式内で break や continue を直接使用できません。
withIndex() は、元のコレクションの要素を IndexedValue オブジェクトにラップした新しいコレクション (またはシーケンス) を生成します。これは forEachIndexed が内部でインデックスをカウントアップするのと比較して、わずかにオーバーヘッドが発生する可能性があります（ただし、通常は無視できる差です）。

withIndex() の内部的な仕組み (簡潔に):

withIndex() は、元のコレクションのイテレータをラップした新しいイテレータ (IndexingIterator) を返します。この新しいイテレータは、元のイテレータから要素を取得するたびに、内部のカウンターをインクリメントし、そのカウンターの値と取得した要素を組み合わせた IndexedValue オブジェクトを返します。

“`kotlin
// イメージ (withIndex() の内部的なイテレータ)
class IndexingIterator(private val iterator: Iterator) : Iterator> {
private var index = 0
override fun hasNext(): Boolean = iterator.hasNext()
override fun next(): IndexedValue {
val value = iterator.next() // 元の要素を取得
return IndexedValue(index++, value) // インデックスをインクリメントしてIndexedValueを作成
}
}

// withIndex() のイメージ
fun Iterable.manualWithIndex(): Iterable> {
return object : Iterable> {
override fun iterator(): Iterator> {
return IndexingIterator([email protected]())
}
}
}

// manualWithIndex() を使った forEach のイメージ
val items = listOf(“a”, “b”)
items.manualWithIndex().forEach { (index, value) ->
println(“$index: $value”)
}
“`

この仕組みにより、withIndex() を他のコレクション操作と組み合わせて、インデックス情報を含んだ中間コレクションを生成したり、遅延評価を行ったりすることが可能になります。

方法3: 古典的な `for` ループ (インデックス範囲を使用)

前述のように、古典的な for ループはインデックスと要素の両方を取得する一般的な方法です。これは forEachIndexed や withIndex().forEach が利用可能になる以前から広く使われている手法であり、現在でも特定の状況下で有用です。

構文:

kotlin for (index in collection.indices) { // または 0 until collection.size val element = collection[index] // index と element を使った処理 }

具体的な使用例:

“`kotlin
val data = mutableListOf(100, 200, 300, 400)

for (i in data.indices) {
// インデックスと要素を使用
println(“Processing element at index $i: ${data[i]}”)

// 例えば、インデックスが偶数なら要素を更新する
if (i % 2 == 0) {
    data[i] = data[i] + 10
}

// 特定の条件でループを中断する
if (data[i] > 310) {
    println("Element exceeds 310 at index $i. Breaking loop.")
    break
}

}
// 出力:
// Processing element at index 0: 100
// Processing element at index 2: 300
// Processing element at index 4: 400 (ここでは実行されない、data[2] が 310 に更新されるため)
// Processing element at index 0: 100
// Processing element at index 1: 200
// Processing element at index 2: 300
// Processing element at index 3: 400
// Processing element at index 0: 100
// Processing element at index 1: 200
// Processing element at index 2: 300
// Element exceeds 310 at index 2. Breaking loop. // i=2の時、data[2]が300+10=310になる
“`

上記の例で示したように、for ループの最大の利点は break と continue を自然に使える点です。

for ループの利点:

break と continue: ループ制御が容易です。
柔軟性: ループの開始インデックスや終了インデックス、ステップサイズなどを細かく制御できます (for (i in 1..5 step 2) など)。
パフォーマンス: 一部のケースでは、関数呼び出しのオーバーヘッドがない分、わずかに高速になる可能性があります（ただし、コンパイラの最適化により、多くの場合 forEachIndexed などとの差は無視できる程度です）。

for ループの欠点:

冗長性: forEachIndexed や withIndex().forEach に比べて、インデックスを使って要素にアクセスする (collection[index]) 記述がやや冗長に感じられることがあります。
可読性 (主観): 要素そのものよりもインデックスの操作に焦点が当たっているように見え、ラムダ式を使った関数型スタイルに慣れている開発者には、やや古典的に映るかもしれません。

方法4: 手動でインデックスを管理 (非推奨)

最後に、カウンター変数を自分で用意し、ループ内でインクリメントする方法です。これは forEach と組み合わせて使うことも可能ですが、非推奨です。

“`kotlin
val items = listOf(“A”, “B”, “C”)
var currentIndex = 0 // 手動でインデックスを管理

items.forEach { item ->
println(“Index $currentIndex: $item”)
currentIndex++ // 手動でインクリメント
}

// 出力:
// Index 0: A
// Index 1: B
// Index 2: C
“`

なぜ非推奨なのか:

可読性の低下: ループの外で変数を宣言し、ループの中でその状態を変更するという手続き的なスタイルは、ラムダ式の関数型スタイルと相性が悪く、コードの流れを追いにくくします。
エラーの可能性: インデックス変数の初期化忘れや、インクリメント忘れ・二重インクリメントなど、ヒューマンエラーが発生しやすくなります。
Kotlinのイディオムからの逸脱: Kotlinでは、このようなインデックス管理は forEachIndexed や withIndex() といった標準ライブラリの機能に任せるのが一般的です。これらの機能を使うことで、コードがより安全で意図が明確になります。

特別な理由がない限り、この方法は避けるべきです。常に forEachIndexed または withIndex().forEach の使用を検討してください。

各方法の比較と使い分け

ここまで、forEach でインデックスを使うための複数の方法を見てきました。それぞれの方法には利点と欠点があり、適切な状況で使用することが重要です。

方法	構文例	インデックスの取得	要素の取得	Break/Continue	可読性	柔軟性 (他の操作との組み合わせ)	内部的な処理 (簡潔)	推奨シナリオ
`forEachIndexed`	`coll.forEachIndexed { i, e -> ... }`	ラムダ引数 `i`	ラムダ引数 `e`	不可(*)	高い	限定的 (単一の処理)	要素取得+インデックスカウント	インデックスと要素を使って各要素に対して副作用を伴う処理を行う場合 (`break`/`continue` 不要)
`withIndex().forEach { }`	`coll.withIndex().forEach { (i, e) -> ... }`	ラムダ引数 `i`	ラムダ引数 `e`	不可(*)	高い	高い (中間操作を挟める)	IndexedValue生成+イテレーション	インデックス情報を含んだ新しいコレクションを生成したい、またはインデックス関連の複雑な処理を挟みたい場合 (`break`/`continue` 不要)
`for (i in coll.indices)`	`for (i in coll.indices) { val e = coll[i]; ... }`	`i` 変数	`coll[i]`	可能	中程度	高い (手続き的に記述)	インデックス範囲イテレーション	`break` や `continue` が必要な場合、またはインデックス範囲を細かく制御したい場合
`for (e in coll.withIndex())`	`for ((i, e) in coll.withIndex()) { ... }`	構造分解 `i`	構造分解 `e`	可能	中程度	高い (withIndex()の柔軟性)	IndexedValue生成+イテレーション	`withIndex()` の柔軟性を利用しつつ `break`/`continue` も必要な場合
手動インデックス管理	`var i = 0; coll.forEach { e -> ... i++ }`	`i` 変数	ラムダ引数 `e`	不可(*)	低い	限定的	要素取得+手動カウント	非推奨 (特別な理由がない限り避ける)

(*) forEach および forEachIndexed では、非ローカルリターンやラベル付きリターンを使って continue 相当の処理や、まれに例外を使って break 相当の処理をエミュレートすることは可能ですが、通常の break/continue ほど直感的ではありません（後述）。

推奨される使い分け:

最も一般的: インデックスと要素の両方を使って各要素に対して単純な処理を行いたい場合で、かつ break や continue が不要な場合は、forEachIndexed が最も簡潔でKotlinらしい書き方です。
kotlin items.forEachIndexed { index, item -> println("Item $index: $item") }
インデックス情報を使った中間操作や柔軟性が必要な場合: インデックスを使って要素をフィルタリングしたり、変換したりといった中間的な操作を挟んでから最終的な処理を行いたい場合や、インデックスと要素のペア (IndexedValue) をそのまま利用したい場合は、withIndex().forEach { ... } が適しています。
kotlin items.withIndex() .filter { (index, _) -> index % 2 == 0 } // インデックスを使ってフィルタ .forEach { (index, item) -> println("Processing even index $index: $item") }
break または continue が必須の場合: ループの途中で処理を中断したり、特定の要素の処理をスキップしたりする必要がある場合は、for ループ (特に for (i in collection.indices)) を使用するのが最も自然で推奨されます。
kotlin for (i in items.indices) { if (i == 2) continue // 2番目の要素はスキップ if (items[i] == "C") break // "C"を見つけたら中断 println("Processing item at index $i: ${items[i]}") }
または、withIndex() を使った for ループも選択肢に入ります。
kotlin for ((index, item) in items.withIndex()) { if (index == 2) continue // 2番目の要素はスキップ if (item == "C") break // "C"を見つけたら中断 println("Processing item at index $index: $item") }
この for ((i, e) in coll.withIndex()) 形式は、break/continue が必要で、かつ coll.indices を使うよりも構造分解で直接要素にアクセスしたい場合に便利です。
非推奨: 手動でのインデックス管理は、特別な理由がない限り避けてください。

`break` と `continue` の代替手段 (`forEach` 系の場合)

前述のように、forEach や forEachIndexed のラムダ式内では、通常の break や continue は使えません。これは、ラムダ式が独立した関数リテラルとして扱われるため、そこからの break や continue が外側のループ（この場合は存在しない）ではなくラムダ式自身に適用されようとするからです。

しかし、Kotlinにはラムダ式からの制御フローを操作するための機能があります。

1. ラベル付きリターン (`return@label`)

continue と同様の挙動をエミュレートするには、ラベル付きリターンを使用します。ラムダ式に明示的なラベルを付け、return@label と記述することで、そのラムダ式の現在の実行を終了し、forEach の次のイテレーションに進むことができます。

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

numbers.forEach {
// continue 相当: 偶数ならスキップ
if (it % 2 == 0) {
println(“Skipping even number: $it”)
return@forEach // ラベル付きリターンで現在のイテレーションを終了
}
println(“Processing odd number: $it”)
}

// 出力:
// Processing odd number: 1
// Skipping even number: 2
// Processing odd number: 3
// Skipping even number: 4
// Processing odd number: 5
// Skipping even number: 6
“`

forEachIndexed や withIndex().forEach { (index, value) -> ... } の場合も同様に、ラムダ式の暗黙的なラベル (@forEachIndexed または @forEach) や明示的なラベルを使用できます。

“`kotlin
val items = listOf(“A”, “B”, “C”, “D”)

items.forEachIndexed { index, item ->
if (index == 1) {
println(“Skipping index 1”)
return@forEachIndexed // continue 相当
}
println(“Processing index $index: $item”)
}

// 出力:
// Processing index 0: A
// Skipping index 1
// Processing index 2: C
// Processing index 3: D
“`

break 相当:

break に相当する、つまりループ全体を中断する処理は、forEach が関数であるため、ラムダ式から非ローカルリターン（そのラムダ式が定義されている外側の関数からのリターン）を行うことで実現できます。ただし、これは forEach がインライン関数である場合にのみ可能です。forEach はインライン関数なので、これは機能します。

“`kotlin
fun processItems(items: List) {
items.forEach { item ->
if (item == “C”) {
println(“Found ‘C’, stopping process.”)
return // processItems 関数全体からのリターン (break 相当)
}
println(“Processing item: $item”)
}
println(“Finished processing all items.”) // “C”が見つかった場合はここは実行されない
}

val data = listOf(“A”, “B”, “C”, “D”)
processItems(data)

// 出力:
// Processing item: A
// Processing item: B
// Found ‘C’, stopping process.
“`

この方法を使うと、forEach が含まれる関数自体から戻ってしまい、その後の処理が実行されなくなります。これはまさに break の挙動と似ています。

注意点:

非ローカルリターンは、forEach がインライン関数であるために可能です。インライン関数でない高階関数のラムダ式内で return を使うと、そのラムダ式自身からのローカルリターンとなります。
ラベル付きリターンや非ローカルリターンを使った break/continue のエミュレーションは、通常の for ループの break/continue に比べて可読性が低下する場合があります。特にネストしたループや複雑な制御フローが必要な場合は、古典的な for ループの方が適していることが多いです。

2. 例外を使用する (非推奨)

非常に特殊なケースとして、break に相当する処理を例外を使って行うことも理論上は可能です。これは、ラムダ式の中でカスタムの例外をスローし、その例外を forEach の呼び出し元でキャッチするという方法です。

“`kotlin
class BreakException : RuntimeException()

val items = listOf(1, 2, 3, 4, 5)

try {
items.forEach { item ->
println(“Processing $item”)
if (item == 3) {
throw BreakException() // break 相当
}
}
} catch (e: BreakException) {
println(“Loop broken.”)
}

// 出力:
// Processing 1
// Processing 2
// Processing 3
// Loop broken.
“`

この方法は、例外処理を通常の制御フローに使うことになり、コードの意図が不明確になり、パフォーマンスにも影響を与える可能性があるため、強く非推奨です。単にループを中断したい場合は、for ループを使うべきです。

応用例と実践的なヒント

インデックス付きのイテレーションは、様々な場面で役立ちます。

例1: リストの要素をインデックス付きで整形して表示

kotlin val products = listOf("Laptop", "Mouse", "Keyboard", "Monitor") products.forEachIndexed { index, product -> val displayIndex = index + 1 // 1から始まるインデックスとして表示 println("$displayIndex. $product") } // 出力: // 1. Laptop // 2. Mouse // 3. Keyboard // 4. Monitor

例2: 特定のインデックスの要素を条件付きで処理

インデックスを使って条件分岐を行うことができます。

“`kotlin
val scores = mutableListOf(80, 95, 70, 88, 92)
scores.forEachIndexed { index, score ->
if (index == 0) { // 最初の要素
println(“First score: $score”)
} else if (index == scores.lastIndex) { // 最後の要素
println(“Last score: $score”)
} else { // 中間の要素
println(“Middle score at index $index: $score”)
}

// 例: インデックスが偶数ならボーナス点を加算
if (index % 2 == 0) {
    scores[index] += 5
    println("  Bonus added. New score: ${scores[index]}")
}

}
println(“Final scores: $scores”)
// 出力例:
// First score: 80
// Bonus added. New score: 85
// Middle score at index 1: 95
// Middle score at index 2: 70
// Bonus added. New score: 75
// Middle score at index 3: 88
// Last score: 92
// Bonus added. New score: 97
// Final scores: [85, 95, 75, 88, 97]
“`

例3: インデックスと要素のペアから新しいリストを作成 (`withIndex() と map()`)

これは withIndex() が非常に便利なケースです。インデックス情報を含んだ別の形式のリストを生成できます。

“`kotlin
val countries = listOf(“Japan”, “USA”, “China”)
val indexedCountries = countries.withIndex().map { (index, country) ->
Pair(index, country.uppercase()) // インデックスと大文字にした国名のペアリストを作成
}
println(indexedCountries) // 出力: [(0, JAPAN), (1, USA), (2, CHINA)]

// または、カスタムデータクラスに変換
data class CountryInfo(val index: Int, val name: String, val isEvenIndex: Boolean)
val countryInfos = countries.withIndex().map { (index, country) ->
CountryInfo(index, country, index % 2 == 0)
}
println(countryInfos)
// 出力: [CountryInfo(index=0, name=Japan, isEvenIndex=true), CountryInfo(index=1, name=USA, isEvenIndex=false), CountryInfo(index=2, name=China, isEvenIndex=true)]
“`

例4: シーケンス (`Sequence`) と `withIndex()`

大量のデータを扱う場合や、複数の処理を連結して効率的に実行したい場合は、コレクションを asSequence() でシーケンスに変換してから操作を行うと、遅延評価の恩恵を受けられます。withIndex() もシーケンスに対して利用可能です。

“`kotlin
val largeList = (1..1000000).toList()

largeList.asSequence() // シーケンスに変換
.withIndex() // インデックス付きシーケンス
.filter { (index, _) -> index < 10 } // 最初の10要素だけを対象
.map { (index, value) -> “Item #$index: $value” } // 文字列に変換
.forEach { println(it) } // 各要素を出力

// 出力 (最初の10件のみ):
// Item #0: 1
// Item #1: 2
// …
// Item #9: 10
`` この例では、filterとmap` は遅延評価されるため、リスト全体ではなく最初の10要素に対してのみ処理が実行され、効率的です。

Nullable なコレクションや要素の扱い

インデックス付きイテレーションは、Nullable なコレクションや要素に対しても通常通り機能します。ラムダ式の要素の型が Nullable であることを適切に扱うだけです。

“`kotlin
val nullableItems: List = listOf(“Apple”, null, “Banana”, “Cherry”)

nullableItems.forEachIndexed { index, item ->
if (item != null) {
println(“Item at index $index is not null: $item”)
} else {
println(“Item at index $index is null.”)
}
}
// 出力:
// Item at index 0 is not null: Apple
// Item at index 1 is null.
// Item at index 2 is not null: Banana
// Item at index 3 is not null: Cherry
“`

パフォーマンスに関する考慮事項

forEachIndexed、withIndex().forEach、および for ループのパフォーマンスについては、一般的に大きな違いはありません。Kotlinコンパイラはこれらの構造を最適化し、ほとんどの場合、基盤となるイテレータ処理やインデックスアクセスは効率的に実行されます。

forEachIndexed は、内部でインデックスを保持・更新するシンプルな処理です。
withIndex() は IndexedValue オブジェクトを作成し、新しいイテレータをラップするというオーバーヘッドがわずかにありますが、現代のJVMやKotlin/Nativeのコンパイラでは効率的に処理されることがほとんどです。
for ループは低レベルなインデックスアクセスやイテレータ操作に直接マッピングされるため、理論上は最も直接的なパスをたどりますが、コンパイラの最適化により他の方法との差は通常小さくなります。

パフォーマンスが極めてクリティカルな場面（例: 非常に巨大なコレクションに対する計算量の多い処理をミリ秒単位で最適化する必要がある場合）では、低レベルな for ループがわずかに有利になる可能性もゼロではありません。しかし、ほとんどのアプリケーションにおいては、パフォーマンスの差は無視できるレベルであり、コードの可読性や保守性を優先して、目的に最も合った方法（forEachIndexed、withIndex().forEach、または for ループ）を選択すべきです。 過度な早期最適化は避けるべきです。

Kotlin標準ライブラリにおける `forEachIndexed` や `withIndex` の利用例

Kotlin標準ライブラリや公式ドキュメント、一般的なKotlinコードパターンでは、これらのインデックス付きイテレーション方法が積極的に活用されています。

UI開発（例: AndroidのRecyclerView）でリストのアイテムを表示する際に、データリストのインデックスとアイテムビューの表示を関連付けるために forEachIndexed や for (i in items.indices) が使われることがあります。
データ変換処理で、要素の値だけでなくその位置情報も考慮する必要がある場合に withIndex() が map, filter などと組み合わせて使われます。
特定のインデックスを持つ要素にアクセスする必要があるアルゴリズムなどで for (i in collection.indices) が使われます。

これらの機能はKotlinの標準的なツールキットの一部であり、Kotlin開発者にとって自然なコーディングスタイルの一部となっています。

まとめ

この記事では、Kotlinでコレクションの要素をイテレーションする際に、要素だけでなくそのインデックスも一緒に利用するための様々な方法について詳細に解説しました。

最も一般的で簡潔な方法は、forEachIndexed 拡張関数を使用することです。これは、インデックスと要素を同時に取得して処理を行うための最も直接的な手段です。
インデックス情報を含んだ中間操作を行いたい場合や、インデックスと要素のペアを別の処理に渡したい場合は、withIndex().forEach { ... } が非常に強力です。withIndex() は map, filter などの他のコレクション操作とも自由に組み合わせられます。
ループの途中で処理を中断する break や、現在のイテレーションをスキップする continue が必要な場合は、古典的な for ループを使用するのが最も自然で推奨されます。for (i in collection.indices) や for ((index, element) in collection.withIndex()) といった形式があります。
手動でインデックス変数を管理する方法は、可読性や安全性の観点から非推奨です。
forEachIndexed や withIndex().forEach で continue 相当の処理を行いたい場合は、ラベル付きリターン (return@label) を使用できます。break 相当の処理は、forEach がインライン関数であることを利用した非ローカルリターンで行うことができますが、複雑な場合は for ループの方が適しています。

どの方法を選択するかは、必要な機能（特に break/continue の有無）とコードの可読性、そして適用したい他のコレクション操作があるかどうかによって異なります。Kotlinはこれらの異なるシナリオに対応するための柔軟なツールを提供しています。

コレクションのイテレーションは日常的なタスクです。これらの方法を理解し、状況に応じて適切に使い分けることで、よりクリーンで効率的、そして意図が明確なKotlinコードを書くことができるようになるでしょう。ぜひ、実際の開発でこれらのテクニックを活用してみてください。