JAVA 이터레이터(Iterator) 패턴

1. 이터레이터(Iterator) 패턴이란?

이터레이터 패턴은 컬렉션의 내부 구조를 노출하지 않고 요소들을 순차적으로 탐색할 수 있도록 도와주는 디자인 패턴입니다. 이 패턴은 컬렉션을 순회하는 방법을 표준화하여, 서로 다른 데이터 구조에서도 일관된 방법으로 요소에 접근할 수 있도록 합니다.

2. 이터레이터 패턴의 주요 개념

이터레이터 패턴은 다음과 같은 구성 요소로 이루어집니다:

• Iterator (인터페이스): 요소를 순차적으로 탐색하는 방법을 정의합니다.
• ConcreteIterator (구체적인 이터레이터): Iterator 인터페이스를 구현하며, 컬렉션의 요소를 탐색합니다.
• Aggregate (인터페이스): 컬렉션 객체를 정의하며, 이터레이터를 생성하는 메서드를 제공합니다.
• ConcreteAggregate (구체적인 컬렉션): Aggregate 인터페이스를 구현하며, 구체적인 이터레이터를 반환합니다.

3. 클래스 다이어그램

       +-----------------------+
       |      Iterator         |
       +-----------------------+
       | + hasNext(): boolean  |
       | + next(): Object      |
       +-----------------------+
                 ^
                 |
       +-----------------------+
       |    ConcreteIterator   |
       +-----------------------+
       | - collection: List    |
       | - currentIndex: int   |
       | + hasNext()           |
       | + next()              |
       +-----------------------+

       +-----------------------+
       |      Aggregate        |
       +-----------------------+
       | + createIterator():   |
       |     Iterator          |
       +-----------------------+
                 ^
                 |
       +-----------------------+
       |   ConcreteAggregate   |
       +-----------------------+
       | + createIterator()    |
       +-----------------------+

4. Java에서의 이터레이터 패턴

Java에서는 Iterator 인터페이스를 제공하여 컬렉션을 순회하는 표준화된 방법을 제공합니다. 이 인터페이스는 다음 두 가지 주요 메서드를 정의합니다:

1. boolean hasNext(): 더 이상 탐색할 요소가 없는 경우 false를 반환합니다.
2. E next(): 현재 요소를 반환하고, 다음 요소로 이동합니다.

예제 코드

아래는 이터레이터 패턴을 사용하여 컬렉션을 순회하는 예제입니다.

4.1 커스텀 이터레이터 구현

import java.util.Iterator;
import java.util.NoSuchElementException;

// Iterator 인터페이스 정의
interface MyIterator<T> {
    boolean hasNext();
    T next();
}

// Aggregate 인터페이스 정의
interface MyAggregate<T> {
    MyIterator<T> createIterator();
}

// ConcreteAggregate 클래스
class MyCollection<T> implements MyAggregate<T> {
    private T[] items;

    public MyCollection(T[] items) {
        this.items = items;
    }

    @Override
    public MyIterator<T> createIterator() {
        return new MyCollectionIterator();
    }

    // ConcreteIterator 클래스
    private class MyCollectionIterator implements MyIterator<T> {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < items.length;
        }

        @Override
        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return items[currentIndex++];
        }
    }
}

public class IteratorPatternDemo {
    public static void main(String[] args) {
        String[] items = {"Apple", "Banana", "Cherry", "Date"};
        MyCollection<String> collection = new MyCollection<>(items);
        MyIterator<String> iterator = collection.createIterator();

        System.out.println("컬렉션 요소 순회:");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

출력 결과

컬렉션 요소 순회:
Apple
Banana
Cherry
Date

5. 결론

이터레이터 패턴은 컬렉션 요소를 순차적으로 탐색할 때 유용하며, 내부 구조를 숨기면서도 요소에 접근할 수 있는 일관된 방법을 제공합니다. Java에서는 이미 Iterator 인터페이스를 제공하므로 다양한 컬렉션 클래스에서 이터레이터를 활용할 수 있습니다.

이번 포스팅에서는 이터레이터 패턴의 개념과 구조를 이해하고, Java로 직접 구현해보았습니다.