Iterator pattern

만약 다음과 같은 상황이라면 우리는 어떤 방법을 취할 수 있을까?

설정

당신이 속한 조직은 라이브러리 파트와 응용 파트로 분리되어 작업한다.

라이브러리 파트는 많은 데이터를 핸들링하며 필요에 따른 컬렉션을 작성하여 응용 파트에 전달한다.

응용 파트는 전달받은 컬렉션을 사용하여 어플리케이션 로직에 적용시켜야 한다.

일정은 촉박하지만, 응용 파트는 라이브러리 파트가 정확히 컬렉션 객체를 전달해주는지 미리 알 수 없다.

당신이 응용 파트의 개발자라면, 이러한 경우에 어떤 조치를 취할 수 있을까?

자바의 컬렉션 객체들(List,Map,Queue,Stack 등)은 저마다 표현하는 방법이 조금씩 상이하다.

List

List<String> arr = new ArrayList();
arr.add("a");
arr.add("b");
arr.add("c");

for(int i=0; i<arr.size(); i++){
    System.out.println(arr.get(i));
}

Queue

Queue queue = new LinkedBlockingQueue();
queue.offer("a");
queue.offer("b");
queue.offer("c");

while(!queue.isEmpty()){
    System.out.println(queue.poll());
}

어떤 자료구조를 선택할 것인지는, 상황과 환경에 따라 매우 유기적으로 변할 수 밖에 없다.

이렇듯 자료구조에 따라 사용자가 원소에 접근하는데 있어서, 구현된 자료구조의 사용법과 구조를 파악하고 있어야만 접근이 가능하다.

Iterator 패턴은 내부의 표현 구조를 노출하지 않고, 이미 정의한 방법으로 원소들을 순회하도록 유도한다.

Aggregate : Iterator 객체를 생성하는 인터페이스
ConcreateAggregate : 해당하는 ConcreateIterator의 인스턴스를 반환하는 Iterator 생성 인터페이스
Iterator : 원소를 접근하고 순회하는데 필요한 인터페이스
ConcreateIterator : Iterator에 정의된 인터페이스를 구현하는 클래스로, 순회 과정 중 집합 객체 내에서 현재 위치를 기억

Aggregate

public interface Aggregate {
    Iterator iterator();
}

ConcreateAggregate

public class Company implements Aggregate{
    private List<Employee> employees;

    public Company(){
        this.employees = new ArrayList<>();
    }

    public Employee getEmployee(int index){
        return this.employees.get(index);
    }

    public void appendEmployee(Employee employee){
        this.employees.add(employee);
    }

    public int employeesSize(){
        return this.employees.size();
    }
    @Override
    public Iterator iterator() {
        return new ListIterator<Employee>(this.employees);
    }
}

Employee

public class Employee {
    private String name;
    private int age;

    public Employee(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return this.name;
    }

    public int getAge(){
        return this.age;
    }
}

Iterator

public interface Iterator<T> {
    boolean hasNext();
    T next();
    T currentItem();
}

ConcreateIterator

public class ListIterator<T> implements Iterator{

    private List<T> list;
    private int size;
    private int currentIndex;

    public ListIterator(List<T> list){
        this.list = list;
        this.size = this.list.size();
        this.currentIndex = 0;
    }

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

    @Override
    public T next() {
        T item = this.list.get(this.currentIndex);
        this.currentIndex++;

        return item;
    }

    @Override
    public Object currentItem() {
        return this.list.get(this.currentIndex);
    }
}

구현하기

Main

public class Main {
    public static void main(String[] args) {
        Company company = new Company();
        company.appendEmployee(new Employee("자바맨", 95));
        company.appendEmployee(new Employee("betterFLY", 14));
        company.appendEmployee(new Employee("슬립친구", 35));

        Iterator<Employee> iterator = company.iterator();
        System.out.println(iterator.currentItem().getName());
        System.out.println(iterator.currentItem().getAge());

        while(iterator.hasNext()){
            Employee employee = iterator.next();
            System.out.println(employee.getName());
        }

    }
}