Iterator Pattern

이터레이터 패턴은 내부 표현부를 노출하지 않고 어떤 집합 객체에 속한 원소들을 순차적으로 접근할 때 사용하는 패턴이다.

활용성

1. 객체 내부 표현 방식을 모르고도 집합 객체의 각 원소들에 접근하고 싶을 때
2. 집합 객체를 순회하는 다양한 방법을 지원하고 싶을 때
3. 서로 다른 집합 객체 구조에 대해서도 동일한 방법으로 순회하고 싶을 때

이터레이터 패턴 사용에 따른 결과

집합 객체의 다양한 순회 방법 제공

구조가 복잡한 집합 객체에 있어서 다양한 순회 방법을 제공할 수 있다. 가령 전위 순회, 후위 순회, 중위 순회를 지원할 수 있다.

집합 객체에 따라 하나 이상의 순회 방법 제공

각 반복자마다 자신의 순회 상태가 있으므로 하나의 집합 객체를 한번에 여러 번 순회시킬 수 있다.

이터레이터

구조

이터레이터의 구조는 다음과 같다.

C++ 구현

void IteratorPattern::IteratorPattern()
{
    auto* iterator = new IteratorClass(3);
    iterator->append(4);
    iterator->append(5);
    iterator->append(6);
    iterator->append(7);
    iterator->loop();

}

template <class T>
class IteratorClass
{
    Iterator<T>* first;
public:
    IteratorClass(T item) {
        first = new Iterator(item);
    }
    IteratorClass() {}

    Iterator<T> get()
    {
        return first;
    }

    void append(T iterator) {
        if (iterator == NULL)
            first = new Iterator<T>(iterator);
        else {
            Iterator<T> *it = first;
            while (it->hasNext())
                it = it->getNext();
            it->append(iterator);
        }
    }

    void loop()
    {
        Iterator<T>* it = first;
        while(it->hasNext())
        {
            std::cout<<it->getData()<<std::endl;
            it = it->getNext();
        }
    }
};

template <class T>
class Iterator
{
    T data;
    Iterator<T>* next;
public:
    Iterator(T data): data(data), next(NULL) {}

    void append(T item)
    {
        next = new Iterator(item);
    }

    bool hasNext()
    {
        return next != NULL;
    }

    T getData()
    {
        return data;
    }

    Iterator<T>* getNext()
    {
        return next;
    }
};

java 구현

public class Client {
    public static void main(String[] args) {
        MyIteratorDataStructure<Integer> iteratorDataStructure = new MyIteratorDataStructure<>();
        iteratorDataStructure.append(1);
        iteratorDataStructure.append(2);
        iteratorDataStructure.append(3);
        iteratorDataStructure.append(4);
        iteratorDataStructure.append(5);

        iteratorDataStructure.loop();
    }
}

public class MyIteratorDataStructure<T> {
    private Node<T> first;

    public MyIteratorDataStructure(T data) {
        first = new Node<>(data);
    }

    public MyIteratorDataStructure() {}

    public void append(T data) {
        if(Objects.isNull(first)) {
            first = new Node<>(data);
        } else {
            Node node = first;
            while(Objects.nonNull(node.getNext()))
                node = node.getNext();
            node.setNext(new Node<>(data));
        }
    }

    public void loop() {
        Node node = first;
        while(Objects.nonNull(node)) {
            node.item();
            node = node.getNext();
        }
    }
}

public class Node<T> {
    private T data;
    private Node<T> next;

    public Node(T data) {
        this.data = data;
    }

    public void setNext(Node<T> next) {
        this.next = next;
    }

    public Node<T> getNext() {
        return next;
    }

    public void item() {
        System.out.println(data);
    }
}