Javaにおける繰り返し処理は、古くから使われている for 文や while 文、そしてJava 5で登場した拡張 for 文など、時代の変遷とともに進化を遂げてきました。

その中でも、Java 8から導入された forEachメソッド は、ラムダ式やStream APIと組み合わせることで、ソースコードの可読性を劇的に向上させる強力なツールとして広く普及しています。

現代のJava開発において、リストやマップなどのコレクション操作を行う際、 forEach を使いこなすことは必須のスキルと言っても過言ではありません。

本記事では、 forEach メソッドの基本的な使い方から、従来の拡張 for 文との違い、ラムダ式やメソッド参照を用いた応用的な記述方法、そして使用時の注意点までを徹底的に解説します。

単なる構文の紹介にとどまらず、内部的な仕組みや実務で役立つテクニックについても深く掘り下げていくため、Javaのプログラミングスキルを一段上のステップへと引き上げる参考にしてください。

目次 [ close ]
  1. JavaのforEachメソッドとは
    1. IterableインターフェースにおけるforEach
    2. MapインターフェースにおけるforEach
  2. forEachの基本的な書き方：ラムダ式とメソッド参照
    1. ラムダ式を用いた記述
    2. メソッド参照を用いた記述
  3. 拡張for文とforEachの違い
    1. 外部イテレータと内部イテレータ
    2. 制御フローの制限
    3. 変数のスコープとeffectively final
  4. MapにおけるforEachの使い方
  5. Stream APIとforEachの連携
    1. フィルタリング後のforEach
    2. StreamのforEachとIterableのforEachの違い
  6. 実務での注意点とベストプラクティス
    1. 1. 例外処理の難しさ
    2. 2. コレクションの構造変更の禁止
    3. 3. 副作用の最小化
    4. 4. パフォーマンスの観点
  7. 高度なTips：forEachOrderedの活用
  8. まとめ

JavaのforEachメソッドとは

Javaの forEach メソッドは、 コレクションの各要素に対して特定の処理を順次実行するためのメソッド です。

Java 8で導入された java.lang.Iterable インターフェース、および java.util.Map インターフェースにデフォルトメソッドとして追加されました。

従来の繰り返し処理では、プログラマが「どのように繰り返すか」という手続き（イテレーションの制御）を記述する 外部イテレータ 方式が一般的でした。

しかし、 forEach は「何を各要素に対して行うか」を定義する 内部イテレータ 方式を採用しています。

これにより、コレクションの反復処理そのものはライブラリ側に任せ、開発者はロジックの記述に集中できるというメリットがあります。

IterableインターフェースにおけるforEach

List や Set などの主要なコレクションクラスはすべて Iterable インターフェースを継承しています。

そのため、これらのクラスのインスタンスに対して直接 .forEach() を呼び出すことが可能です。

このメソッドは、引数として java.util.function.Consumer を受け取ります。

MapインターフェースにおけるforEach

Map は Iterable を直接継承していませんが、Java 8において独自の forEach メソッドが追加されました。

こちらは java.util.function.BiConsumer を引数に取り、キーと値の両方を同時に扱うことができます。

forEachの基本的な書き方：ラムダ式とメソッド参照

forEach を利用する最大の利点は、コードが簡潔になることです。

ここでは、最も一般的なラムダ式を用いた記述方法と、さらに簡略化されたメソッド参照について解説します。

ラムダ式を用いた記述

ラムダ式を使用すると、匿名クラスを定義することなく、簡潔に関数オブジェクトを記述できます。

基本的な構文は以下の通りです。

Java
コレクション.forEach(変数名 -> {
    // 各要素に対する処理
});

具体的なコード例を見てみましょう。

Java
import java.util.Arrays;
import java.util.List;

public class ForEachBasicExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");

        // ラムダ式を使用して各要素を出力
        fruits.forEach(fruit -> {
            System.out.println("フルーツ名: " + fruit);
        });
    }
}
実行結果
フルーツ名: Apple
フルーツ名: Banana
フルーツ名: Cherry

メソッド参照を用いた記述

ラムダ式の処理が単一のメソッドを呼び出すだけであれば、 メソッド参照 を使用してさらにコードを短縮できます。

記述形式は クラス名::メソッド名 です。

Java
import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // メソッド参照を用いた記述
        names.forEach(System.out::println);
    }
}
実行結果
Alice
Bob
Charlie

メソッド参照を使用すると、 「何をするか」が直感的に理解しやすくなる ため、可能な限りこちらを選択することが推奨されます。

拡張for文とforEachの違い

forEach の導入以前、Javaで最も一般的だった反復処理は拡張 for 文（Enhanced for loop）でした。

一見すると似たような働きをしますが、設計思想や制約に大きな違いがあります。

外部イテレータと内部イテレータ

もっとも根本的な違いは、イテレータの制御主体です。

拡張for文（外部イテレータ）

プログラマがループを制御します。

要素を取り出すタイミングや、ループの途中で中断する処理を自由に記述できます。

forEach（内部イテレータ）

コレクション側がループを制御します。

各要素に対するアクションを渡すだけで、どのように要素を巡回するかはコレクションの実装に依存します。

制御フローの制限

forEach を使用する上で最も注意すべき点は、 breakやcontinueが使用できない という点です。

ラムダ式内での return は、現在の要素に対する処理を終了（拡張 for 文での continue に相当）させますが、ループ全体を抜けることはできません。

項目拡張for文forEachメソッド
中断（break）可能不可
スキップ（continue）可能returnで代替可能
ローカル変数の更新可能不可（実質的にfinalである必要あり）
可読性記述量が増えがち非常に簡潔
Stream APIとの連携不可非常に親和性が高い

変数のスコープとeffectively final

ラムダ式内から外部のローカル変数を参照する場合、その変数は effectively final（実質的にfinal） でなければなりません。

つまり、一度代入した値をループ内で書き換えることは禁止されています。

一方、拡張 for 文ではループの外で定義した変数を自由に更新できます。

Java
// 拡張for文の場合：変数の更新が可能
int sum = 0;
for (int n : numbers) {
    sum += n; 
}

// forEachの場合：コンパイルエラーになる
int total = 0;
// numbers.forEach(n -> total += n); // エラー：totalはfinalである必要がある

MapにおけるforEachの使い方

Map インターフェースでの forEach は、キーと値のペアを効率的に処理するために設計されています。

従来の Map.entrySet() を用いたループよりも格段に読みやすくなります。

Java
import java.util.HashMap;
import java.util.Map;

public class MapForEachExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "Python");
        map.put(3, "C++");

        // キーと値を同時に処理
        map.forEach((id, name) -> {
            System.out.println("ID: " + id + ", 言語: " + name);
        });
    }
}
実行結果
ID: 1, 言語: Java
ID: 2, 言語: Python
ID: 3, 言語: C++

このように、 Map.forEach は (key, value) -> { ... } という形式のラムダ式（BiConsumer）を受け取るため、エントリーセットを取り出す手間が省けます。

Stream APIとforEachの連携

forEach メソッドは Iterable インターフェースだけでなく、 Stream API においても終端操作として提供されています。

Stream APIを活用することで、フィルタリングやマッピングといった加工を施した後に、最終的な出力や保存処理を行うことができます。

フィルタリング後のforEach

特定の条件に合致する要素だけを抽出して処理する例です。

Java
import java.util.Arrays;
import java.util.List;

public class StreamForEachExample {
    public static void main(String[] args) {
        List<String> members = Arrays.asList("Tanaka", "Sato", "Suzuki", "Takahashi");

        // "T"で始まる名前だけを出力
        members.stream()
               .filter(name -> name.startsWith("T"))
               .forEach(name -> System.out.println("対象者: " + name));
    }
}
実行結果
対象者: Tanaka
対象者: Takahashi

StreamのforEachとIterableのforEachの違い

一見同じように見えますが、 Stream.forEach() と Iterable.forEach() には重要な違いがあります。

実行のタイミング

Iterable.forEach() は即座に実行されますが、 Stream.forEach() はストリームのパイプラインが構築され、終端操作として呼び出されるまで実行されません。

並列処理

Stream.parallelStream() を使用した場合、 forEach は複数のスレッドで並列に実行されます。

この際、順序が保証されないことに注意が必要です。

順序を維持したい場合は forEachOrdered() を使用します。

実務での注意点とベストプラクティス

forEach は便利なメソッドですが、何でも forEach で書けば良いというわけではありません。

アンチパターンを避け、適切な場面で使い分けることが重要です。

1. 例外処理の難しさ

ラムダ式内では、チェック例外（Checked Exception）をそのままスローすることができません。

ラムダ式内で発生した例外を処理するには、内部で try-catch ブロックを記述するか、実行時例外（RuntimeException）にラップして投げ直す必要があります。

これにより、コードが煩雑になる場合があります。

Java
// ラムダ内での例外処理（冗長になりがち）
list.forEach(item -> {
    try {
        process(item); // チェック例外を投げるメソッド
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
});

2. コレクションの構造変更の禁止

forEach でループを回している最中に、そのソースとなっているコレクション自体から要素を削除したり、追加したりすることは避けてください。

これは拡張 for 文でも同様ですが、 ConcurrentModificationException が発生する原因となります。

要素の削除を行いたい場合は Iterator.remove() や Collection.removeIf() を使用するのが適切です。

3. 副作用の最小化

関数型プログラミングの観点からは、 forEach の中で外部の状態（変数の値など）を変更するような 副作用 を持つ処理は最小限にすべきとされています。

単に出力やログ記録を行うのであれば問題ありませんが、複雑な計算結果を外部に蓄積するような処理は、 Stream.collect() や Stream.reduce() を検討してください。

4. パフォーマンスの観点

通常の ArrayList などの処理において、 forEach と拡張 for 文の速度差は無視できるほど微小です。

しかし、非常に巨大なデータセットや極限のパフォーマンスが求められる環境では、従来の for 文の方がオーバーヘッドが少ない場合があります。

とはいえ、多くのビジネスアプリケーションにおいては、 パフォーマンスよりもコードの可読性と保守性 を優先すべきであり、その点において forEach は非常に優れています。

高度なTips：forEachOrderedの活用

並列ストリームを使用する場合、 forEach は処理の順序を考慮しません。

しかし、リストの順序を守りつつ並列処理の恩恵（一部）を受けたい、あるいは最終的な出力順を保証したい場合には forEachOrdered が役立ちます。

Java
import java.util.Arrays;
import java.util.List;

public class ForEachOrderedExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        System.out.println("--- parallel().forEach() ---");
        numbers.parallelStream().forEach(System.out::print);

        System.out.println("\n--- parallel().forEachOrdered() ---");
        numbers.parallelStream().forEachOrdered(System.out::print);
    }
}

【実行結果（例）】

--- parallel().forEach() ---
35421
--- parallel().forEachOrdered() ---
12345

parallelStream() と forEach を組み合わせると出力がバラバラになりますが、 forEachOrdered を使うと、元のリストの順序（出現順）に従って出力されることがわかります。

まとめ

Javaの forEach メソッドは、モダンなJava開発において欠かせない重要な機能です。

ラムダ式やメソッド参照と組み合わせることで、従来のループ記述よりもはるかに簡潔で、意図が明確なコードを書くことができます。

今回の内容を整理すると、以下のポイントが重要です。

  • 内部イテレータ方式 により、反復処理の制御をカプセル化し、ロジックを簡潔にする。
  • List 、 Set だけでなく Map でも専用の forEach が利用可能。
  • breakやcontinueは使用できない ため、ループの中断が必要な場合は従来の拡張 for 文を使用する。
  • 外部変数を参照する場合は effectively final の制約がある。
  • 並列ストリーム利用時は順序保証のために forEachOrdered の使い分けが必要。

forEach は決して万能ではありませんが、適切な場面で利用することで、コードの品質を大きく向上させます。

特にStream APIとの連携においてはその真価を発揮するため、各メソッドの特性を正しく理解し、状況に応じた最適な反復処理を選択できるようになりましょう。

日常的なコーディングの中で少しずつ forEach を取り入れ、よりクリーンでメンテナンス性の高いJavaプログラムを目指してください。