MENU
  1. ホーム
  2. Java
  3. Javaのイテレータパターンを使ったコレクション要素の反復処理を徹底解説

Javaのイテレータパターンを使ったコレクション要素の反復処理を徹底解説

Java

Javaにおいて、コレクション要素の反復処理は、プログラムの効率性や可読性に大きな影響を与えます。特に、イテレータパターンを使用することで、コレクションの内部構造を意識せずに要素を一つずつ処理できるため、柔軟で安全な操作が可能です。本記事では、Javaのイテレータパターンの基本から実際の使い方までを解説し、さらにカスタムコレクションやスレッドセーフなイテレータの実装方法についても取り上げます。これにより、Javaプログラミングでの反復処理の理解が深まります。

目次
  1. イテレータパターンとは
    1. イテレータパターンの利点
  2. Javaでのイテレータの利用方法
    1. 基本的なIteratorの使い方
    2. コード解説
  3. コレクションフレームワークとイテレータ
    1. ArrayListでのイテレータの使用
    2. HashSetでのイテレータの使用
    3. LinkedListでのイテレータの使用
    4. イテレータの利便性
  4. hasNext()とnext()メソッドの役割
    1. hasNext()メソッドの役割
    2. next()メソッドの役割
    3. hasNext()とnext()の組み合わせ
    4. 例外処理の必要性
  5. イテレータのremove()メソッドの使い方
    1. remove()メソッドの役割
    2. remove()の動作の詳細
    3. remove()メソッド使用時の注意点
  6. 拡張forループ（for-each）の利点と制限
    1. 拡張forループの利点
    2. 拡張forループの制限
    3. イテレータとの使い分け
  7. イテレータとスレッドセーフ処理
    1. スレッドセーフでないイテレータの問題点
    2. スレッドセーフなコレクションの使用
    3. 同期化を利用したスレッドセーフ処理
    4. イテレータとスレッドセーフ処理のまとめ
  8. Iterableインターフェースの役割
    1. Iterableインターフェースの基本構造
    2. Iterableインターフェースを実装するクラス
    3. コード解説
    4. Iterableのメリット
    5. 実装時の注意点
  9. 実践例: カスタムコレクションでのイテレータ使用
    1. カスタムコレクションの設計
    2. コード解説
    3. カスタムコレクションでのイテレータの利点
    4. 実践での利用場面
    5. カスタムコレクションを拡張する
  10. イテレータの応用: フィルタリング処理
    1. フィルタリング処理の基本
    2. コード解説
    3. カスタムフィルタリングロジックの実装
    4. コード解説
    5. フィルタリングの応用場面
    6. イテレータによるフィルタリングのまとめ
  11. まとめ

イテレータパターンとは

イテレータパターンは、コレクション内の要素に順番にアクセスするためのデザインパターンです。このパターンを利用することで、コレクションの内部実装に依存せずに、要素を反復処理できます。Javaの標準コレクションフレームワークでは、すべてのコレクションがこのパターンを実装しており、簡単に要素の反復が可能です。

イテレータパターンの利点

  • カプセル化の促進：コレクションの内部構造に依存せずに、要素を順次処理できるため、内部の実装変更が他のコードに影響しません。
  • 簡素なコード：シンプルなAPI（hasNext(), next()）を使用することで、可読性の高いコードが書けます。
  • 柔軟な反復処理：配列やリスト、セットなど、異なるコレクション型に対しても共通の方法で要素を反復処理できます。

Javaでのイテレータの利用方法

Javaでは、Iteratorインターフェースを使ってコレクション要素を順次処理できます。このインターフェースは、すべてのコレクションフレームワークでサポートされており、ListやSetなどのコレクションで使用可能です。基本的な使い方として、コレクションからイテレータを取得し、hasNext()とnext()メソッドを利用して反復処理を行います。

基本的なIteratorの使い方

以下は、ArrayListを使用した基本的なイテレータの使用例です。

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

コード解説

  1. iterator()メソッドを呼び出して、コレクションからイテレータを取得します。
  2. hasNext()メソッドで次の要素が存在するかを確認します。
  3. next()メソッドで次の要素を取得し、処理を行います。

この構文により、コレクション内のすべての要素を効率的に処理できます。

コレクションフレームワークとイテレータ

Javaのコレクションフレームワークは、さまざまなデータ構造をサポートしており、それぞれでイテレータを使用することができます。具体的には、List、Set、Mapといった主要なコレクションクラスに対してイテレータを用いることで、内部のデータ構造を意識せずに要素の反復処理が可能です。

ArrayListでのイテレータの使用

ArrayListは、順序を保持する可変長の配列です。ArrayListに格納された要素をイテレータで反復処理する方法は以下の通りです。

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListIteratorExample {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        Iterator<Integer> iterator = numbers.iterator();

        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

ArrayListに対してイテレータを使うと、順序通りに要素を処理できます。

HashSetでのイテレータの使用

HashSetは順序を保証しないセットの実装です。このデータ構造でもイテレータを使って要素を順番に処理できますが、要素の順序は保存されません。

import java.util.HashSet;
import java.util.Iterator;

public class HashSetIteratorExample {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("A");
        set.add("B");
        set.add("C");

        Iterator<String> iterator = set.iterator();

        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

LinkedListでのイテレータの使用

LinkedListは、ArrayListと同様に順序を保持しますが、連結リストで構造が異なります。LinkedListでもイテレータを使用して要素を順番に処理することができます。

import java.util.LinkedList;
import java.util.Iterator;

public class LinkedListIteratorExample {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("First");
        list.add("Second");
        list.add("Third");

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

イテレータの利便性

イテレータを使うことで、リストやセットといった異なるコレクションに対しても一貫した方法で反復処理が行えるため、コードの柔軟性が向上します。また、内部構造に依存せずに処理できるため、コレクションの変更があっても影響を最小限に抑えることができます。

hasNext()とnext()メソッドの役割

Javaのイテレータを使用する際、最も重要なメソッドがhasNext()とnext()です。これらのメソッドは、イテレータを使ってコレクション要素を順次処理するための基本的な操作を提供します。hasNext()は次に処理する要素が存在するかを確認し、next()は実際に次の要素を取得します。

hasNext()メソッドの役割

hasNext()メソッドは、イテレータの現在の位置から次の要素が存在するかどうかをチェックします。これにより、ループが終了すべきかどうかを判断できます。次に要素が存在する場合はtrueを返し、存在しない場合はfalseを返します。

以下の例では、hasNext()を使って次の要素がある限りループを続ける処理を示します。

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    // 次の要素があるかを確認する
    String element = iterator.next();
    System.out.println(element);
}

next()メソッドの役割

next()メソッドは、イテレータの現在の位置から次の要素を返します。このメソッドは、イテレータが保持している順序に従ってコレクションから次の要素を取得するため、hasNext()で確認してから使用するのが一般的です。hasNext()を使わずにnext()を呼び出すと、要素がない場合にNoSuchElementExceptionがスローされるため注意が必要です。

以下にnext()メソッドの使い方を示します。

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    // 次の要素を取得
    String element = iterator.next();
    System.out.println(element);
}

hasNext()とnext()の組み合わせ

通常、hasNext()で次の要素が存在するかを確認し、次にnext()を使ってその要素を取得します。この組み合わせにより、エラーを回避しつつ、安全にコレクション内の全要素を処理できます。

Iterator<Integer> numbers = list.iterator();
while (numbers.hasNext()) {
    System.out.println(numbers.next());
}

例外処理の必要性

next()は、次の要素が存在しないときに呼び出すとNoSuchElementExceptionをスローします。これを防ぐため、必ずhasNext()を確認してからnext()を呼び出す必要があります。

これらのメソッドの適切な組み合わせを使うことで、イテレータを用いた安全で効率的なコレクション要素の反復処理が可能になります。

イテレータのremove()メソッドの使い方

Javaのイテレータには、要素を削除するためのremove()メソッドが用意されています。このメソッドを使用すると、コレクションから現在の要素を安全に削除できます。通常、コレクションの反復中に要素を削除しようとするとConcurrentModificationExceptionが発生するリスクがありますが、イテレータのremove()メソッドを使うことでこれを回避できます。

remove()メソッドの役割

remove()メソッドは、next()メソッドで取得した直前の要素をコレクションから削除します。これにより、反復処理中でも安全に要素を削除できます。ただし、next()を呼び出す前にremove()を使用すると、IllegalStateExceptionが発生するため、必ずnext()で要素を取得した後に削除操作を行う必要があります。

以下の例では、イテレータを使用して特定の条件に一致する要素を削除しています。

import java.util.ArrayList;
import java.util.Iterator;

public class RemoveExample {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext()) {
            String fruit = iterator.next();
            if (fruit.equals("Banana")) {
                iterator.remove();  // "Banana" を削除
            }
        }

        System.out.println(list);  // [Apple, Orange]
    }
}

remove()の動作の詳細

  1. next()で取得した要素のみを削除することができ、コレクションの他の要素には影響しません。
  2. remove()を使用してコレクションを変更すると、他の要素に対するイテレータの操作は問題なく続行されます。
  3. remove()を呼び出す前にnext()を実行しないとIllegalStateExceptionがスローされます。

remove()メソッド使用時の注意点

  • remove()はnext()で直前に取得した要素にのみ適用可能です。それ以前やそれ以外の要素には適用できないため、操作は慎重に行う必要があります。
  • remove()を使う際には、コレクションの構造が安全に変更されるように、イテレータを正しく操作し、意図しない削除や例外を避けることが大切です。

このremove()メソッドを使うことで、コレクション要素を効率的に削除しながら、安全に反復処理を行うことができます。

拡張forループ（for-each）の利点と制限

Javaでは、イテレータを明示的に使う方法以外に、拡張forループ（for-eachループ）を使ってコレクション要素を簡潔に反復処理することができます。拡張forループは、内部的にイテレータを使用しており、簡単に書けるうえ、コードの可読性が向上します。しかし、いくつかの制約があるため、場合によってはイテレータを直接使用する必要もあります。

拡張forループの利点

拡張forループは、コレクションや配列の要素を簡潔に処理するための便利な方法です。以下は、その主な利点です。

  1. 簡潔な構文：イテレータやインデックスを明示的に使用することなく、要素を反復処理できます。
  2. 可読性の向上：コードが短く、シンプルに見えるため、コレクション内の全要素に対する処理が一目でわかります。
  3. エラー回避：手動でインデックスを管理する必要がないため、インデックスアウトオブバウンズエラーのリスクが減少します。

以下の例では、拡張forループを使ってArrayListの要素を処理しています。

import java.util.ArrayList;

public class ForEachExample {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        for (String language : list) {
            System.out.println(language);
        }
    }
}

この例では、for (String language : list)という構文を使用することで、list内の各要素を順番に処理しています。イテレータを明示的に使わないため、コードがシンプルで読みやすくなります。

拡張forループの制限

拡張forループには便利な側面がある一方で、いくつかの制限もあります。

  1. 要素の削除ができない：拡張forループでは、イテレータのremove()メソッドを使用できないため、コレクションの要素を反復処理しながら削除することができません。要素を削除したい場合は、通常のイテレータを使用する必要があります。
  2. 反復処理の制御が難しい：拡張forループでは、イテレータのnext()やhasNext()を直接操作できないため、反復処理の細かな制御が難しい場合があります。
  3. インデックスへのアクセス不可：拡張forループは、インデックスを利用してコレクション要素にアクセスすることができません。そのため、インデックスが必要な場面では従来のforループやイテレータを使う必要があります。

以下に、拡張forループで要素を削除できない例を示します。

import java.util.ArrayList;

public class ForEachRemoveExample {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        for (String language : list) {
            if (language.equals("Python")) {
                // list.remove(language); // 実行時エラーが発生する
            }
        }
    }
}

この例では、list.remove()を直接呼び出そうとすると、ConcurrentModificationExceptionが発生します。こういった場合、イテレータを明示的に使用する必要があります。

イテレータとの使い分け

拡張forループは、単純な反復処理には非常に便利ですが、要素の削除や細かな制御が必要な場合にはイテレータを使う方が安全で効果的です。両者の利点を理解し、用途に応じて使い分けることが重要です。

イテレータとスレッドセーフ処理

マルチスレッド環境でコレクションを扱う際、スレッド間の競合を避けるために、イテレータの使用には特に注意が必要です。Javaのコレクションはスレッドセーフではないものが多く、複数のスレッドが同時にコレクションにアクセスした場合、ConcurrentModificationExceptionが発生する可能性があります。スレッドセーフな処理を行うためには、適切な同期やスレッドセーフなコレクションを使用する必要があります。

スレッドセーフでないイテレータの問題点

一般的なArrayListやHashSetなどのコレクションは、複数のスレッドが同時に変更を加えると、イテレータの反復中に不正な状態になる可能性があります。以下のような場合、ConcurrentModificationExceptionが発生します。

import java.util.ArrayList;

public class NonThreadSafeExample {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        Runnable task = () -> {
            for (Integer num : list) {
                System.out.println(num);
                list.add(4);  // イテレータが進行中にコレクションを変更
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();
    }
}

この例では、listがイテレートされている間に別のスレッドが要素を追加するため、ConcurrentModificationExceptionが発生する可能性があります。

スレッドセーフなコレクションの使用

スレッドセーフなコレクションを使用することで、スレッド間の競合を防ぐことができます。java.util.concurrentパッケージには、スレッドセーフなコレクションが多数用意されており、代表的なものとしてCopyOnWriteArrayListやConcurrentHashMapがあります。

以下は、CopyOnWriteArrayListを使用したスレッドセーフなイテレータの例です。

import java.util.concurrent.CopyOnWriteArrayList;

public class ThreadSafeIteratorExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        Runnable task = () -> {
            for (Integer num : list) {
                System.out.println(num);
                list.add(4);  // スレッドセーフなコレクションはエラーを回避
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();
    }
}

CopyOnWriteArrayListは、要素の変更が行われるたびにリストのコピーを作成するため、反復処理中でも安全に要素を追加したり削除したりできます。ただし、コレクションのサイズが大きくなると、パフォーマンスが低下する可能性があるため注意が必要です。

同期化を利用したスレッドセーフ処理

スレッドセーフでないコレクションを使用しながらも、同期化を行うことでスレッド間の競合を防ぐことも可能です。Collections.synchronizedList()メソッドを使って、既存のコレクションを同期化することができます。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SynchronizedListExample {
    public static void main(String[] args) {
        List<Integer> list = Collections.synchronizedList(new ArrayList<>());
        list.add(1);
        list.add(2);
        list.add(3);

        Runnable task = () -> {
            synchronized (list) {  // 明示的に同期ブロックを使用
                for (Integer num : list) {
                    System.out.println(num);
                    list.add(4);
                }
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();
    }
}

この例では、synchronizedブロックを使用することで、複数のスレッドが同時にコレクションにアクセスすることを防いでいます。Collections.synchronizedList()メソッドにより、スレッドセーフなリストが作成されますが、イテレーション中に変更を加える場合は明示的に同期ブロックを使うことが推奨されます。

イテレータとスレッドセーフ処理のまとめ

  • 複数のスレッドでイテレータを使う場合、スレッドセーフでないコレクションでは競合が発生する可能性があるため注意が必要です。
  • CopyOnWriteArrayListやConcurrentHashMapなどのスレッドセーフなコレクションを使用するか、同期化されたコレクションで明示的に同期ブロックを使うことで、スレッド間の競合を防ぎます。

Iterableインターフェースの役割

JavaのIterableインターフェースは、コレクションの要素を反復処理するための基礎となるインターフェースです。Iterableを実装することで、そのクラスはfor-eachループやイテレータを使用した反復処理をサポートすることができます。Javaの標準コレクション（ListやSetなど）はすべてこのインターフェースを実装していますが、独自のコレクションを作成する場合にも、このインターフェースを実装することでイテレータを活用することが可能です。

Iterableインターフェースの基本構造

Iterableインターフェースには、単一のメソッドiterator()が定義されています。このメソッドは、そのクラスの要素を反復処理するためのIteratorオブジェクトを返します。

public interface Iterable<T> {
    Iterator<T> iterator();
}

Iterableインターフェースを実装するクラス

カスタムクラスにIterableインターフェースを実装することで、そのクラスの要素をイテレータで反復処理できるようになります。以下は、Iterableインターフェースを実装したカスタムコレクションの例です。

import java.util.Iterator;

public class CustomCollection implements Iterable<String> {
    private String[] items;
    private int size;

    public CustomCollection(int size) {
        this.size = size;
        items = new String[size];
        for (int i = 0; i < size; i++) {
            items[i] = "Item " + i;
        }
    }

    @Override
    public Iterator<String> iterator() {
        return new CustomIterator();
    }

    private class CustomIterator implements Iterator<String> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < size;
        }

        @Override
        public String next() {
            return items[index++];
        }
    }

    public static void main(String[] args) {
        CustomCollection collection = new CustomCollection(5);
        for (String item : collection) {
            System.out.println(item);
        }
    }
}

コード解説

  1. CustomCollectionクラスは、Iterable<String>インターフェースを実装しており、その内部でiterator()メソッドをオーバーライドしています。
  2. CustomIteratorクラスは、Iteratorインターフェースを実装しており、hasNext()およびnext()メソッドを定義します。このクラスを使って、CustomCollection内の要素を反復処理できます。
  3. for-eachループを使用して、CustomCollection内の要素を順次出力しています。

Iterableのメリット

  • for-eachループ対応：Iterableインターフェースを実装することで、for-eachループを利用した簡潔なコードが記述できるようになります。
  • 柔軟なカスタムイテレータの実装：Iterableインターフェースにより、カスタムコレクションに対して独自の反復処理ロジックを提供できます。
  • 標準的なAPIとの互換性：Iterableを実装することで、コレクションの操作に標準的なJava APIが利用できるようになります。

実装時の注意点

Iterableを実装する場合、必ずiterator()メソッドをオーバーライドし、Iteratorオブジェクトを返すようにします。また、イテレータのメソッドhasNext()とnext()を適切に実装することで、コレクション全体を安全かつ効率的に反復処理できるようにします。

このように、Iterableインターフェースはコレクション要素の反復処理を提供するための基本的な仕組みを提供し、for-eachループや標準イテレータの使用を可能にします。

実践例: カスタムコレクションでのイテレータ使用

Javaでカスタムコレクションを作成し、そのコレクションでイテレータを使用することで、独自のデータ構造を効率的に反復処理できるようになります。ここでは、Iterableインターフェースを実装したカスタムコレクションと、そのイテレータを使った具体的な実装例を紹介します。これにより、既存のコレクションに制約されることなく、自分のニーズに合った反復処理を実装する方法がわかります。

カスタムコレクションの設計

ここでは、簡単な整数コレクションを作成し、その中でイテレータを使って要素を順次処理する例を見てみます。このカスタムコレクションは、Iterableインターフェースを実装し、要素を反復処理できるように設計されています。

import java.util.Iterator;

public class IntCollection implements Iterable<Integer> {
    private int[] numbers;
    private int size;

    public IntCollection(int size) {
        this.size = size;
        numbers = new int[size];
        for (int i = 0; i < size; i++) {
            numbers[i] = i + 1;  // コレクションに初期値を設定
        }
    }

    @Override
    public Iterator<Integer> iterator() {
        return new IntIterator();
    }

    private class IntIterator implements Iterator<Integer> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < size;  // 次の要素が存在するかを確認
        }

        @Override
        public Integer next() {
            return numbers[index++];  // 次の要素を返し、インデックスを進める
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Remove not supported.");
        }
    }

    public static void main(String[] args) {
        IntCollection collection = new IntCollection(5);
        for (Integer number : collection) {
            System.out.println(number);
        }
    }
}

コード解説

  1. コレクションの定義
    IntCollectionクラスは、指定されたサイズで整数配列を生成します。これにより、コレクションが初期化され、反復処理が可能な状態になります。
  2. イテレータの実装
    IntCollection内にIntIteratorという内部クラスを作成し、Iterator<Integer>インターフェースを実装しています。このクラスでは、hasNext()とnext()メソッドをオーバーライドし、コレクション内の要素を順番に返すロジックを提供しています。
  3. 反復処理の実行
    for-eachループを使用して、IntCollection内の要素を順次処理しています。これにより、IntCollectionの要素が1から5まで順に出力されます。

カスタムコレクションでのイテレータの利点

  • 柔軟性：標準コレクションに制約されることなく、独自のデータ構造を設計し、必要に応じてイテレータをカスタマイズできます。
  • 再利用性：カスタムコレクションを他のプロジェクトでも使い回せるため、独自の反復処理ロジックを構築して応用できます。
  • 安全性：remove()メソッドのように、不要な操作をサポートしないように設計することで、コレクションの不正な操作を防げます。

実践での利用場面

このカスタムコレクションは、特定のアルゴリズムを適用したいときや、特殊なデータ構造を持つオブジェクトを反復処理したいときに非常に役立ちます。たとえば、数列やフィボナッチ数、独自のフィルタリングロジックを持つデータなど、通常のコレクションには存在しないデータ型に対しても、適切な反復処理が可能です。

カスタムコレクションを拡張する

この例を基に、より複雑なカスタムコレクションを作成することもできます。たとえば、カスタムコレクションに追加メソッドを実装したり、イテレータにフィルタリング機能を持たせることが考えられます。

カスタムイテレータの使用は、特定の要件に応じた高度なコレクション操作を実現する上で重要な技術です。この方法を習得することで、Javaでのコレクション操作における柔軟性とパフォーマンスが大幅に向上します。

イテレータの応用: フィルタリング処理

イテレータは、単純なコレクション要素の反復処理だけでなく、特定の条件に基づいてコレクション要素をフィルタリングするためにも活用できます。Javaのイテレータを応用することで、コレクションの一部要素だけを処理する柔軟なロジックを構築でき、データの前処理や不要なデータの除外が簡単になります。

フィルタリング処理の基本

イテレータを使ったフィルタリングでは、特定の条件に基づいて要素を選別し、必要な要素だけを反復処理します。以下の例では、コレクション内の偶数の要素のみをフィルタリングして出力します。

import java.util.ArrayList;
import java.util.Iterator;

public class FilteredIteratorExample {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);  // 1から10までの数字を追加
        }

        Iterator<Integer> iterator = numbers.iterator();

        while (iterator.hasNext()) {
            Integer number = iterator.next();
            if (number % 2 != 0) {
                iterator.remove();  // 奇数の要素を削除
            }
        }

        System.out.println(numbers);  // 偶数のみが残る: [2, 4, 6, 8, 10]
    }
}

コード解説

  1. コレクションの準備
    ArrayListに1から10までの整数を追加し、イテレータを取得します。
  2. フィルタリングロジックの実装
    whileループ内でnext()メソッドを使ってコレクション要素を取得し、条件分岐（number % 2 != 0）で奇数かどうかを判定します。奇数の要素が見つかった場合は、remove()メソッドを使用してその要素をコレクションから削除します。
  3. 結果の出力
    フィルタリング処理後に、コレクションには偶数の要素だけが残り、[2, 4, 6, 8, 10]と出力されます。

カスタムフィルタリングロジックの実装

さらに高度なフィルタリングを行うために、カスタムイテレータを実装することも可能です。以下の例では、カスタムフィルタリングイテレータを実装して、指定された条件に一致する要素のみを反復処理する方法を紹介します。

import java.util.Iterator;
import java.util.function.Predicate;

public class FilteredIterator<T> implements Iterator<T> {
    private Iterator<T> iterator;
    private Predicate<T> predicate;
    private T nextElement;
    private boolean hasNextElement;

    public FilteredIterator(Iterator<T> iterator, Predicate<T> predicate) {
        this.iterator = iterator;
        this.predicate = predicate;
        moveToNext();
    }

    private void moveToNext() {
        while (iterator.hasNext()) {
            T element = iterator.next();
            if (predicate.test(element)) {
                nextElement = element;
                hasNextElement = true;
                return;
            }
        }
        hasNextElement = false;
    }

    @Override
    public boolean hasNext() {
        return hasNextElement;
    }

    @Override
    public T next() {
        T result = nextElement;
        moveToNext();
        return result;
    }
}

このカスタムイテレータでは、指定された条件（Predicate<T>）を満たす要素だけを順次返します。以下は、このフィルタリングイテレータを使用して偶数だけを出力する例です。

import java.util.ArrayList;
import java.util.Iterator;

public class FilteredIteratorTest {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);  // 1から10までの数字を追加
        }

        Iterator<Integer> filteredIterator = new FilteredIterator<>(numbers.iterator(), n -> n % 2 == 0);

        while (filteredIterator.hasNext()) {
            System.out.println(filteredIterator.next());  // 偶数のみ出力
        }
    }
}

コード解説

  1. FilteredIteratorの設計
    カスタムフィルタリングイテレータは、内部でPredicate<T>を受け取り、条件に基づいて要素をフィルタリングします。
  2. フィルタリング処理の実行
    FilteredIteratorTestクラスで、このカスタムイテレータを使い、偶数のみをフィルタリングして出力します。n -> n % 2 == 0という条件が、偶数をフィルタリングするためのPredicateです。

フィルタリングの応用場面

フィルタリングイテレータは、大量のデータを扱う際に特定の条件に基づいて不要なデータを除外する場合に有用です。たとえば、データベースから取得したレコードをメモリ内で処理する前に、不要な項目をフィルタリングすることで、パフォーマンスやメモリ効率を向上させることができます。

イテレータによるフィルタリングのまとめ

イテレータは、コレクション内の要素を効率的にフィルタリングするために強力なツールです。標準のremove()メソッドを使用した簡単なフィルタリングから、カスタムイテレータを実装して複雑な条件に基づくフィルタリングまで、さまざまなシナリオで活用できます。これにより、コレクション操作の柔軟性が大幅に向上し、より効率的なデータ処理が可能になります。

まとめ

本記事では、Javaのイテレータパターンを使ったコレクション要素の反復処理について解説しました。イテレータの基本的な使い方から、hasNext()やnext()メソッド、さらにはカスタムコレクションやフィルタリングの応用例までを紹介しました。イテレータを活用することで、コレクションの内部構造に依存せず、安全かつ柔軟に要素を処理できるようになります。スレッドセーフなコレクションやカスタムフィルタリングイテレータを駆使することで、より効率的で高度な反復処理が可能です。

Java
java コレクション イテレータ

コメント

コメントする

目次
  1. イテレータパターンとは
    1. イテレータパターンの利点
  2. Javaでのイテレータの利用方法
    1. 基本的なIteratorの使い方
    2. コード解説
  3. コレクションフレームワークとイテレータ
    1. ArrayListでのイテレータの使用
    2. HashSetでのイテレータの使用
    3. LinkedListでのイテレータの使用
    4. イテレータの利便性
  4. hasNext()とnext()メソッドの役割
    1. hasNext()メソッドの役割
    2. next()メソッドの役割
    3. hasNext()とnext()の組み合わせ
    4. 例外処理の必要性
  5. イテレータのremove()メソッドの使い方
    1. remove()メソッドの役割
    2. remove()の動作の詳細
    3. remove()メソッド使用時の注意点
  6. 拡張forループ（for-each）の利点と制限
    1. 拡張forループの利点
    2. 拡張forループの制限
    3. イテレータとの使い分け
  7. イテレータとスレッドセーフ処理
    1. スレッドセーフでないイテレータの問題点
    2. スレッドセーフなコレクションの使用
    3. 同期化を利用したスレッドセーフ処理
    4. イテレータとスレッドセーフ処理のまとめ
  8. Iterableインターフェースの役割
    1. Iterableインターフェースの基本構造
    2. Iterableインターフェースを実装するクラス
    3. コード解説
    4. Iterableのメリット
    5. 実装時の注意点
  9. 実践例: カスタムコレクションでのイテレータ使用
    1. カスタムコレクションの設計
    2. コード解説
    3. カスタムコレクションでのイテレータの利点
    4. 実践での利用場面
    5. カスタムコレクションを拡張する
  10. イテレータの応用: フィルタリング処理
    1. フィルタリング処理の基本
    2. コード解説
    3. カスタムフィルタリングロジックの実装
    4. コード解説
    5. フィルタリングの応用場面
    6. イテレータによるフィルタリングのまとめ
  11. まとめ