反復 (Iteration) は、同じ処理を繰り返し実行することで、コードの簡潔さと再利用性を向上させるためによく使用されます。Javaには、様々な方法で反復処理を行うことができます。たとえば、for文、while文、do-while文、拡張for文、Iterator、forEachメソッドなどがあります。
このチュートリアルでは、これらの反復処理方法を解説し、それぞれの使用方法や適切な場面について説明します。また、配列やコレクションに対する反復処理、ループ制御についても解説します。
反復処理は、プログラミングにおいて非常に重要な概念であり、プログラムの処理効率や保守性を向上させるためにも、しっかりと理解しておく必要があります。本チュートリアルを通じて、反復処理について深く理解し、効果的に使用するための知識を身につけましょう。
__TOC__ 
次のサンプルは、一応Hello worldの日本語版です。
Hello world同様、実用的な意味はありませんが、反復処理の例となっています。
[https://paiza.io/projects/MIpF5Jaxi_ctaWgY3eQG3Q?language=java Main.java]:
class Main {
    public static void main(String[] args) {
        String hello = "世界🌍よこんにちは😀";
        for (int i = 0, len = hello.length(); i < len; i = hello.offsetByCodePoints(i, 1)) {
            System.out.println(Character.toChars(hello.codePointAt(i)));
        }
    }
}
」があることに注意してください）。
コンパイルして実行してみましょう。
$ javac Main.java
$ java Main
世
界
🌍
よ
こ
ん
に
ち
は 
😀
“縦書き”でメッセージが表示されます。
このプログラムはwhile文を使って次のように書くこともできます。
[https://paiza.io/projects/bFx1DL73ySHmROH5vTNVTg?language=java 例]:
class Main {
    public static void main(String[] args) {
        String hello = "世界🌍よこんにちは😀";
        int i = 0, len = hello.length(); 
        while (i < len) {
            System.out.println(Character.toChars(hello.codePointAt(i)));
            i = hello.offsetByCodePoints(i, 1);
        }
    }
}
さらにdo-while文を使って次のような書き方もできます。
[https://paiza.io/projects/qTVeB09G6GWDdNJflv3_mg?language=java 例]:
class Main {
    public static void main(String[] args) {
        String hello = "世界🌍よこんにちは😀";
        int i = 0, len = hello.length(); 
        do {
            System.out.println(Character.toChars(hello.codePointAt(i)));
            i = hello.offsetByCodePoints(i, 1);
        } while (i < len);
    }
}
またさらに、CharSequence#codePoints()でコードポイントのStreamを取得し、これのforEachメソッドで繰返しを行う次のような書き方も可能です。
これが最もシンプルな書き方です。
[https://paiza.io/projects/lkDPc897-el1UBm5t1Dd3w?language=java 例]:
class Main {
    public static void main(String[] args) {
        new String("世界🌍よこんにちは😀").codePoints().forEach(cp -> System.out.println(Character.toChars(cp)));
    }
}
もはや構文ですらありませんが、サロゲートペアを含むコードポイントの列を繰返していることを簡素に表現できています。
各構文の詳細を説明する前に、共通する要素について説明します。
反復には、必ず反復条件を伴います。反復は、反復条件が満たされている間だけ続けられ、条件が満たされなくなると終了する。
反復条件は、比較演算子を使って表現されることがあります。
比較演算子は不等号などの数学記号に似ています。
==演算子は、プリミティブ型の値またはオブジェクトの参照を比較するために使用されます。!=演算子は、==演算子と同じように使用されますが、2つの値が等しくない場合にtrueを返します。
<、>、<=、>=演算子は、プリミティブ型の値の大小関係を比較するために使用されます。
instanceof演算子は、オブジェクトの型を調べるために使用されます。左辺が右辺のクラスのインスタンスである場合、trueを返します。
注意点としては、オブジェクトの比較に==演算子を使用すると、オブジェクトの参照を比較するため、同じ内容のオブジェクトでもfalseを返す場合があります。
オブジェクトの内容を比較する場合は、.equals()メソッドを使用する必要があります。
Javaのfor文は、反復処理を行うための制御構造の一つで、指定された回数または条件を満たすまで繰り返します。一般的に、以下の形式で使用されます。
for (初期化式; 継続条件式; 更新式) {
    // 反復処理の本体
}
初期化式
初期化式は、反復処理が始まる前に一度だけ評価される式で、反復処理の前に何らかの変数を初期化するために使用されます。
初期化式では変数を宣言することができ、初期化式で宣言された変数のスコープはfor文が終わるまでです。
継続条件式
継続条件式は、反復処理が継続するかどうかを判定するための式で、trueかfalseを返します。この式がtrueを返し続ける限り、反復処理が繰り返されます。
継続条件式がfalseを返した場合、反復処理は終了します。
更新式
更新式は、反復処理の本体が実行された後に評価される式で、反復変数などの値を更新するために使用されます。
for文の本体は、継続条件式がtrueを返す間、繰り返し実行されます。通常、変数の値を使って何らかの処理を行います。
以下は、1から10までの整数を出力する例です。
for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}
このコードは、1から10までの整数を順番に出力するための反復処理を行います。
for文の初期化式 int i = 1 では、反復処理で使用する変数 i を1で初期化しています。
継続条件式 i <= 10 では、変数 i の値が10以下の間、反復処理を繰り返すことを指定しています。
更新式 i++ では、変数 i を1ずつ増加させます。
反復処理の本体 System.out.println(i) では、変数 i の値を画面に出力しています。
つまり、初期値が1であり、10以下の間、変数 i を1ずつ増加させながら、各ループで変数 i の値を画面に出力することを指定しているため、1から10までの整数が順番に出力されます。
for文の学習と言えば、典型的な例が掛け算九九を表示するサンプルです。
class Main {
    public static void main(String[] args) {
        for (int y = 1; y <= 9; y++) {
            for (int x = 1; x <= 9; x++) {
                 String buf = String.format("%dx%d=%2d ", x, y, x * y);
                 System.out.print(buf);
            }
            System.out.println();
        }
    }
}
外側のforループは、行ごとに反復処理を行います。 内側のforループは、各行に対して、列ごとに反復処理を行います。
内側のforループの中で、String.formatメソッドを使って、現在の行と列の値に対応する九九の計算結果を文字列として作成し、それをSystem.out.printメソッドで出力しています。
外側のforループの最後には、改行を出力するためにSystem.out.printlnメソッドを呼び出しています。これにより、各行が改行で区切られて表示されるようになります。
Javaにおいて、拡張for文（またはfor-each文）は、配列やコレクションなどの要素を繰り返し処理するための簡潔な方法を提供します。
標準的なforループとは異なり、ループカウンタを使用する必要がなく、ループ対象のデータ型に応じてループ変数を明示的に宣言する必要がありません。
構文は以下のようになります。
for (要素の型 変数名 : 配列またはコレクション) {
    // 繰り返し処理
}
以下に、配列やコレクションを用いた拡張for文の例を示します。
// 配列の例
int[] nums = {1, 2, 3, 4, 5};
for (int num : nums) {
    System.out.println(num);
}
// コレクションの例
List fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("banana");
fruits.add("orange");
for (String fruit : fruits) {
    System.out.println(fruit);
}
この例では、配列numsの要素を順に表示するためにint型のループ変数numを使用し、同様に、コレクションfruitsの要素を順に表示するためにString型のループ変数fruitを使用しています。
拡張for文を使用することで、コードがより簡潔で読みやすくなります。
{{コラム|拡張for文|2=なお、この例では配列を使って説明していますが、拡張for文が使えるのは配列だけではありません。（少し先取りした内容になりますが）コレクションフレームワークや、もっと一般的に言うとIterable<E>を実装したクラスが拡張for文で使えます。具体的には、
for (E var1 : /* Iterableを実装したクラスのインスタンス */) {
  // ここに処理を書く
}
という構文になります。
拡張for文は、そうしたインスタンスにも配列同様の考え方で適用することができます。
Javaにおけるwhile文は、指定した条件式がtrueである間、反復処理を続ける制御構造です。構文は以下の通りです。
 
while (条件式) {
    // 反復処理の本体
}
条件式がtrueである限り、中括弧内の文が繰り返し実行されます。条件式がfalseになった時点で、while文の実行は終了します。
例えば、1から10までの整数を出力するプログラムは以下のように書けます。
 
int i = 1;
while (i <= 10) {
    System.out.println(i);
    i++;
}
このプログラムでは、変数iを1で初期化し、iが10以下である限り、iを出力してiを1ずつ増やしています。
これをStreamを使用して書き換えることができます。
IntStream.rangeClosed(1, 10)
         .forEach(System.out::println);
IntStream.rangeClosed(1, 10)は、1から10までの整数のストリームを生成します。そして、.forEach(System.out::println)で各要素を出力しています。
rangeClosed()メソッドは指定された範囲（この場合は1から10まで）の整数ストリームを生成します。このストリームを使用して各要素に対して操作を行うことができます。
Javaにおいて、whileループを使ってファイルを読み込む方法について説明します。
以下は、例としてファイルの中身を1行ずつ読み込み、コンソールに出力するプログラムです。
 
import java.io.*;
public class FileReadDemo {
    public static void main(String[] args) {
        try {
            // ファイルの読み込みに必要な準備
            BufferedReader br = new BufferedReader(new FileReader("input.txt"));
            String line;
            // ファイルの1行ずつ読み込み
            while ((line = br.readLine()) != null) {
                // 読み込んだ行をコンソールに出力
                System.out.println(line);
            }
            // ファイルを閉じる
            br.close();
        } catch (IOException e) {
            System.out.println("ファイル読み込みエラー");
        }
    }
}
まず、BufferedReader クラスを使ってファイルを読み込むための準備をします。BufferedReader クラスは、テキストファイルを1行ずつ読み込むためのクラスで、FileReader クラスと組み合わせて使用します。
while ループ内では、BufferedReader オブジェクトの readLine() メソッドを使って、ファイルから1行ずつデータを読み込みます。読み込んだ行が null でない場合は、読み込んだ行をコンソールに出力します。
ファイルの読み込みが終了したら、ファイルを閉じるために close() メソッドを呼び出します。また、エラーが発生した場合は、例外処理を行います。
このように、while ループを使ってファイルを読み込むことができます。ただし、ファイルの読み込みには例外処理が必要であることに注意してください。
のような書き方について
と書かれています。
これは代入演算と比較演算を同時に行う書き方で、こうした類の処理によく使われるパターンですが、慣れない間は奇異に見えるかもしれません。
なぜこうした書き方が可能なのかというと、代入演算の式は、その式で代入結果の値を返すからです。
念のため、処理の流れを追ってみましょう。
が返されると考えてよいでしょう。
になった場合、行はそれ以上ないというサインなので、ループから抜ける必要があります。
参考：for文で書いた場合
上記のサンプルは、for文を使ってたとえば
import java.io.*;
public class FileReadDemo {
    public static void main(String[] args) {
        try {
            // ファイルの読み込みに必要な準備
            BufferedReader br = new BufferedReader(new FileReader("input.txt"));
            String line;
            // ファイルの1行ずつ読み込み
            for (line = br.readLine(); line != null; line = br.readLine()) {
                // 読み込んだ行をコンソールに出力
                System.out.println(line);
            }
            // ファイルを閉じる
            br.close();
        } catch (IOException e) {
            System.out.println("ファイル読み込みエラー");
        }
    }
}
と書くこともできます。
コードの効率性や可読性、保守性なども考慮して判断する必要があります。
参考：Streamを使った場合
さらに、ファイル読み込みのコードをStreamを使用して書き換えることができます。BufferedReaderからの行のストリームを取得し、それを使用して各行を処理する方法があります。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
public class FileReadDemo {
    public static void main(String[] args) {
        try {
            // ファイルの1行ずつストリームとして読み込む
            Files.lines(Paths.get("input.txt"))
                    .forEach(System.out::println);
        } catch (IOException e) {
            System.out.println("ファイル読み込みエラー");
        }
    }
}
 
このコードでは、Files.lines(Paths.get("input.txt"))を使用して、ファイルを行のストリームとして読み込んでいます。そして、.forEach(System.out::println)を使って、各行をコンソールに出力しています。
Files.lines()はファイルを行のストリームとして読み込む便利な方法です。それを使用することで、BufferedReaderを明示的に使わずにファイルをストリームとして扱うことができます。
Javaのdo-while文は、while文と同じくループ処理を行うための構文の1つです。ただし、while文と異なり、do-while文はループの最初に1度だけブロック内の処理を実行し、その後に条件式を評価します。条件式がtrueの場合、再びブロック内の処理を実行します。条件式がfalseの場合、ループから抜けます。
do-while文の基本構文は以下のようになります。
do {
  // 処理
} while (条件式);
例えば、1から10までの整数を順番に出力する場合は、次のようにdo-while文を使用することができます。
int i = 1;
do {
    System.out.println(i);
    i++;
} while (i <= 10);
このコードでは、変数iを初期化してから、doブロック内でiを出力し、iを1増やしています。その後、while文でiが10以下である限り、doブロックを繰り返し実行します。結果として、1から10までの整数が順番に出力されます。
do-while文は、ループの最初に必ず1度だけブロック内の処理を実行する必要がある場合に使用することができます。また、条件式がfalseであっても、ブロック内の処理を最低1回実行することが保証されるため、while文と異なり、特定の処理を必ず実行する必要がある場合にも適しています。
JavaのIteratorは、コレクションオブジェクト内の要素を順番に取得するためのインターフェースです。Iteratorは、Javaのコレクションフレームワークの一部であり、java.utilパッケージに含まれています。
Iteratorを使用することで、配列やリストなどのコレクションオブジェクトの要素を順番に取得し、処理を行うことができます。Iteratorは、以下の3つのメソッドを持っています。
boolean hasNext(): 次の要素がある場合にtrueを返します。
E next(): 次の要素を返します。
void remove(): 最後に返された要素をコレクションから削除します。
Iteratorの基本的な使い方は、以下のようになります。
 
Iterator it = collection.iterator();   // イテレータを取得
while (it.hasNext()) {                    // 次の要素がある場合
    E element = it.next();                // 次の要素を取得
    // 要素に対する処理
}
ここで、collectionは要素を持つコレクションオブジェクトです。まず、iterator()メソッドを使用してイテレータを取得し、hasNext()メソッドで次の要素があるかどうかを確認します。次の要素がある場合、next()メソッドで次の要素を取得し、処理を行います。
また、Iteratorは、要素を削除するためのremove()メソッドを持っています。このメソッドを使用する場合は、必ずnext()メソッドで要素を取得した直後に呼び出す必要があります。例えば、次のように使用することができます。
 
Iterator it = collection.iterator();
while (it.hasNext()) {
    E element = it.next();
    if (条件) {
        it.remove();  // 条件に合致する要素を削除
    }
}
Iteratorを使用することで、コレクションオブジェクトの要素を順番に取得し、必要な処理を行うことができます。ただし、Iteratorは単方向のイテレーションしかサポートしていないため、要素の逆順の処理が必要な場合は、リストイテレータを使用することが推奨されます。
JavaのforEachメソッドは、Java 8から導入された機能で、配列やコレクションの要素を繰り返し処理するためのメソッドです。forEachメソッドは、以下のように使用します。
 
arrayOrCollection.forEach(element -> {
    // 要素に対する処理
});
ここで、arrayOrCollectionは、要素を持つ配列またはコレクションオブジェクトです。forEachメソッドは、要素ごとに指定された処理を行うためのラムダ式を引数として受け取ります。
ラムダ式は、->を用いて定義されます。上記の例では、elementという変数が要素を表し、{}内には要素に対する処理が記述されます。この場合、forEachメソッドは、配列またはコレクションの要素を繰り返し、各要素に対して指定された処理を行います。
forEachメソッドは、拡張for文に比べて、コードを簡潔に書くことができます。また、複数の要素に対して同じ処理を行う場合にも適しています。
forEachメソッドは、配列やコレクションの要素を順番に処理するため、要素の追加や削除などの操作を行う場合は、for文またはIteratorを使用する必要があります。また、forEachメソッドは、並列処理にも対応しており、parallelStreamメソッドと組み合わせて使用することで、複数のスレッドを使用した並列処理が可能です。
Javaのコレクションフレームワークを使用してリスト（List）、セット（Set）、およびマップ（Map）を作成し、それらの要素を表示する例
import java.util.*;
public class CollectionExample {
    public static void main(String[] args) {
        // Listの例
        List stringList = List.of("apple", "banana", "orange");
        // forEachメソッドを使って要素を表示
        stringList.forEach(System.out::println);
        // Setの例
        Set integerSet = Set.of(1, 2, 3, 4, 5);
        // forEachメソッドを使って要素を表示
        integerSet.forEach(System.out::println);
        // Mapの例
        Map numberMap = Map.of(
            1, "One",
            2, "Two",
            3, "Three"
        );
        // forEachメソッドを使ってキーと値を表示
        numberMap.forEach((key, value) -> System.out.println(key + " : " + value));
    }
}
コードの概要：
Listを使用して、3つの文字列を持つリスト stringList を作成しています。それから、forEach メソッドを使用して、リストの各要素を改行して表示しています。
Setを使用して、5つの整数を持つセット integerSet を作成しています。同様に、forEach メソッドを使用して、セットの各要素を改行して表示しています。
Mapを使用して、3つの整数をキーとし、それに対応する文字列を値とするマップ numberMap を作成しています。forEach メソッドを使用して、マップの各エントリー（キーと値のペア）をキーと値の形式で表示しています。
各コレクション（リスト、セット、マップ）は、Java 9で導入された List.of()、Set.of()、Map.of() メソッドを使用して作成されています。これらのメソッドは、不変のコレクションを作成し、指定された要素で初期化する便利な方法を提供します。そして、forEach メソッドは、各要素に対して指定されたアクション（この場合は表示）を実行するために使用されています。
List.ofメソッドは、指定された要素から不変のリストを作成するために使用されます。つまり、この場合、"apple", "banana", "orange" の3つの要素を持つリストが作成されます。
そして、forEachメソッドは、リスト内の各要素に対して指定されたアクションを実行します。System.out::printlnは、メソッド参照を使っています。これはprintlnメソッドへの参照を表しています。
つまり、fruits.forEach(System.out::println);は、リストの各要素をSystem.out.printlnメソッドを使って出力するという意味です。
{{コラム|ofメソッド|2=Javaのofメソッドは、Java 9から導入された静的メソッドであり、不変（immutable）なコレクション（List、Set、Map）を作成するための便利な方法を提供します。このメソッドは、複数の要素をコンパクトな方法で指定し、それらの要素を含む不変のコレクションを生成します。
ofメソッドを使用する主な理由は次の通りです：
不変性の確保: ofメソッドで作成されたコレクションは不変（immutable）です。つまり、一度作成された後はその内容を変更することができません。この性質は、プログラムの安全性とスレッドセーフ性を高めるのに役立ちます。
コードの可読性と簡潔さ: ofメソッドは、コレクションを作成するためのリテラル構文よりも簡潔で読みやすいコードを提供します。複数の要素を指定するための煩雑なコードを省略できます。
エラープルーフ: ofメソッドは可変長引数を取るため、要素を列挙する際にコンパイル時のチェックを提供します。これにより、コンパイル時にエラーを検出することができます。また、要素の型が一致しない場合や、nullを渡した場合には実行時に例外がスローされます。
ただし、ofメソッドにはいくつかの制限もあります。例えば、作成されるコレクションの要素数に制限があること、不変性を保つために要素の追加や削除ができないこと、またnull要素を受け付けないことなどが挙げられます。
したがって、短い要素のリストや、要素が事前にわかっている場合にはofメソッドを使用することでコードの可読性と堅牢性を高めることができます。ただし、要素が動的に変化する可能性がある場合や、大量の要素を扱う場合には、他の手法やコレクションの生成方法を検討する必要があります。
メソッドチェインは、Javaで複数のメソッド呼び出しを1つの文でつなげて書く方法です。これにより、コードがより簡潔で読みやすくなります。例を見てみましょう。
import java.util.List;
import java.util.stream.Collectors;
public class MethodChainingExample {
    public static void main(String[] args) {
        List words = List.of("apple", "banana", "orange", "grape", "peach");
        // 文字数が5未満の単語を取り出し、大文字に変換してカンマ区切りの文字列にする
        String result = words.stream()
            .filter(word -> word.length() < 5) // 文字数が5未満の単語をフィルタリング
            .map(String::toUpperCase) // 単語を大文字に変換
            .collect(Collectors.joining(", ")); // カンマ区切りの文字列に変換
        System.out.println(result);
    }
}
この例では、List.ofメソッドを使用してリストを作成し、それをストリームに変換しています。そして、メソッドチェインを使用していくつかの処理を行っています。
filter: 文字数が5未満の単語をフィルタリングします。
map: フィルタリングされた単語を大文字に変換します。
collect: 変換された単語をカンマ区切りの文字列に集約します。
これにより、1つのストリーム処理内で複数の操作を行い、最終的な結果を得ることができます。メソッドチェインを使うと、コードがシンプルで、各ステップが連続しているため、処理の流れがより明確になります。
{{コラム|メソッドチェインの長所短所|2=メソッドチェインにはいくつかの長所と短所があります。
長所:
コードの可読性向上: メソッドチェインを使用することで、複数のメソッド呼び出しを1行で表現できます。これにより、コードが簡潔になり、処理の流れが直感的に理解しやすくなります。
柔軟性と拡張性: メソッドチェインは、メソッドを順番に適用するため、フィルタリングやマッピングなどの処理を柔軟に組み合わせることができます。また、新しい処理が追加される場合も、既存のメソッドチェインに容易に組み込むことができます。
効率性の向上: 一連の操作をメソッドチェインでつなげることで、中間データ構造を作成することなく処理をパイプライン化できます。これにより、メモリの使用を最適化し、効率的な処理を実現できます。
短所:
デバッグが難しいこと: メソッドチェインが長くなると、デバッグやエラーの特定が難しくなる場合があります。特に途中で行われる変換やフィルタリングなど、一連の操作が複雑になると、それぞれのステップでのデータの状態を理解するのが困難になることがあります。
可読性の低下: あまりにもメソッドチェインが長すぎる場合、コードの可読性が低下する可能性があります。メソッドチェインが複雑になると、理解しやすさが損なわれることがあります。
エラーハンドリングの複雑化: メソッドチェイン内でエラーが発生した場合、どのメソッド呼び出しで問題が発生したのか特定することが難しくなることがあります。エラーのハンドリングやトラブルシューティングが複雑になる可能性があります。
メソッドチェインは、適切に使用されるとコードをスッキリとさせ、処理の流れを明確にすることができます。しかし、過度に長くなると可読性が低下したり、デバッグが難しくなるリスクもあるため、バランスを考えながら適切に利用することが重要です。
以下は、Javaで反復処理を行う際に使用する主要な文法とメソッドのチートシートです。
for文
for (初期化式; 条件式; 更新式) {
  // 処理
}
初期化式: ループの最初に一度だけ実行され、変数の初期化を行う。
条件式: 毎回ループの開始時に評価され、真偽値を返す。
更新式: ループの最後に毎回実行され、変数の更新を行う。
while文
while (条件式) {
  // 処理
}
条件式: 毎回ループの開始時に評価され、真偽値を返す。
do-while文
do {
  // 処理
} while (条件式);
条件式: ループの最後に一度だけ評価され、真偽値を返す。
Enhanced for文
for (型 変数名 : 配列またはコレクション) {
  // 処理
}
型: 配列またはコレクションに含まれる要素の型。
変数名: ループ内で要素にアクセスするための変数名。
Iterator
Iterator<型> iterator = コレクション.iterator();
while (iterator.hasNext()) {
  型 要素 = iterator.next();
  // 処理
}
型: コレクションに含まれる要素の型。varを使うと型推論が可能。
iterator(): コレクションからイテレータを取得するメソッド。
hasNext(): 次の要素があるかどうかを判定するメソッド。
next(): 次の要素を取得するメソッド。
forEachメソッド
配列またはコレクション.forEach(要素 -> {
  // 処理
});
forEach(): 配列またはコレクションの要素を1つずつ取り出して、ラムダ式による処理を実行するメソッド。
要素 -> {}: ラムダ式の記法。要素に対する処理を記述する。
ループ (Loop)：同じ処理を繰り返し実行するプログラム構造。Javaではfor文、while文、do-while文などがあり、配列やコレクションに対しても反復処理を行うことができる。
初期化式 (Initialization)：for文で使用される、ループの最初に一度だけ実行される式。変数の宣言と初期化を行うことができる。
条件式 (Condition)：ループの開始時に評価される式。真偽値を返す。
更新式 (Update)：for文やwhile文で使用される、ループの最後に毎回実行される式。変数の更新などを行うことができる。
配列 (Array)：同じ型の複数の値を格納できる、固定長のデータ構造。インデックスを指定することで個々の要素にアクセスすることができる。
コレクション (Collection)：複数のオブジェクトを格納するための可変長のデータ構造。Javaでは、List、Set、Mapなどがある。
Enhanced for文 (Enhanced for loop)：配列やコレクションに対して反復処理を行うための構文。for (型 変数名 : 配列またはコレクション) { // 処理 }の形式で記述する。
Iterator：コレクションに対して反復処理を行うためのインターフェース。hasNext()、next()などのメソッドを提供する。
forEachメソッド (forEach)：配列やコレクションに対してラムダ式を用いて反復処理を行うためのメソッド。配列またはコレクション.forEach(要素 -> { // 処理 });の形式で記述する。