구조안을 돌아다니며 처리 - Iterator Pattern

1. Iterator Pattern?

---

• 객체 요소들의 내부 표현방식을 공개하지 않고, 객체를 순회하는 객체를 만듦.
• collection을 생각하면 편함.

 

 

2. 의도와 동기

---

• 내부에서 객체의 순차적인 제공을 하지 않음
• 순회 구현 방식이 다르더라도 동일한 방식(메서드)로 순회할 수 있게 제공
• 여러 리스트 객체에 대한 동일한 방식으로 순회하는 방법을 제공하기 위해 순회하는 객체를 따로 만듦.
• 예) Java Collection Framework의 Iterator

 

 

3. Class Diagram

---

 

 

4. 객체 협력 (collaborations)

---

• Iterator

요소에 접근하고 순회하는데 필요한 메서드 제공

• CocreteIterator

Iterator에 정의된 인터페이스를 구현하는 클래스

• Aggregate

Iterator 객체를 생성하는 인터페이스 정의

• ConcreteAggregate

해당하는 ConcreteIteratir의 인스턴스를 반환하도록 Iterator 생성 인터페이스를 구현

 

 

5. 중요한 결론 (consequence)

---

• ConcreteIterator는 리스트를 순회하면서 각 리스트의 요소를 반환하는 메서드도 제공한다.
• 다양한 순회방법이 제공될 수 있다.
• 동일한 Aggregate를 구현한 클래스들은 동일한 방식으로 순회할 수 있다.

 

 

 

6. 예제

---

public class Book {
    private String name = "";
    public Book(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Constant {
    public static final int FORWARD = 0;
    public static final int REVERSE = 1;
}

public abstract class Factory {

    //template 메서드 패턴
    public final Iterator create(Aggregate list, int type){
        Iterator p = createProduct(list, type);
        return p;
    }

    public abstract Iterator createProduct(Aggregate list, int type);
}

public class IteratorFactory extends Factory{
    //싱글톤
    private static IteratorFactory iteratorFactory = new IteratorFactory();

    private IteratorFactory() {
    }

    public static IteratorFactory getInstance() {
        return iteratorFactory;
    }

    @Override
    public Iterator createProduct(Aggregate bookshelf, int type) {
        if (type == Constant.FORWARD){
            return new ForwardIterator(bookshelf);
        }
        else if (type == Constant.REVERSE){
            return new ReverseIterator(bookshelf);
        }
        return null;
    }
}

public interface Aggregate {
    public abstract Iterator iterator(int type);
    public int getLength();
}

public class BookShelf implements Aggregate{

    private Book[] books;
    private int last = 0;
    Factory f = IteratorFactory.getInstance();

    public BookShelf(int maxsize) {
        this.books = new Book[maxsize];
    }

    public Book getBookAt(int index){
        return books[index];
    }

    public void appendBook(Book book){
        this.books[last] = book;
        last++;
    }


    @Override
    public Iterator iterator(int type) {
        return f.create(this, type);
    }

    @Override
    public int getLength() {
        return last;
    }
}

public interface Iterator {

    public abstract boolean hasNext();
    public abstract Object next();

}

public class ForwardIterator implements Iterator{

    BookShelf bookShelf;
    private int index;

    public ForwardIterator(Aggregate list) {
        bookShelf = (BookShelf) list;
        index = 0;
    }

    @Override
    public boolean hasNext() {
        if (index < bookShelf.getLength()){
            return true;
        }
        return false;
    }

    @Override
    public Object next() {
        Book book = bookShelf.getBookAt(index);
        index++;
        return book;
    }
}

public class ReverseIterator implements Iterator{
    BookShelf bookShelf;
    private int index;

    public ReverseIterator(Aggregate list) {
        bookShelf = (BookShelf) list;
        index = bookShelf.getLength()-1;
    }

    @Override
    public boolean hasNext() {
        if (index >= 0){
            return true;
        }
        return false;
    }

    @Override
    public Object next() {
        Book book = bookShelf.getBookAt(index);
        index--;
        return book;
    }
}

public class Main {

    public static void main(String[] args) {
        BookShelf bookShelf = new BookShelf(4);
        bookShelf.appendBook(new Book("book A"));
        bookShelf.appendBook(new Book("book B"));
        bookShelf.appendBook(new Book("book C"));
        bookShelf.appendBook(new Book("book D"));

        Iterator iterator = bookShelf.iterator(Constant.FORWARD);
        while (iterator.hasNext()){
            Book next = (Book) iterator.next();
            System.out.println(next.getName());
        }
        System.out.println("==================");

        iterator = bookShelf.iterator(Constant.REVERSE);
        while (iterator.hasNext()){
            Book next = (Book) iterator.next();
            System.out.println(next.getName());
        }
        System.out.println("==================");
    }
}

book A
book B
book C
book D
==================
book D
book C
book B
book A
==================

 

 

7. GitHub : 211113 Iterator Pattern

---

GitHub - bsh6463/designPattern