eidherProvide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
Participants
- Iterator: defines an interface for accessing and traversing elements.
- ConcreteIterator: implements the Iterator interface. Keeps track of the current position in the traversal of the aggregate.
- Aggregate: defines an interface for creating an Iterator object
- ConcreteAggregate: implements the Iterator creation interface to return an instance of the proper ConcreteIterator
Code
public class Main {
public static void main(String[] args) {
String items[] = { "Item A", "Item B", "Item C", "Item D" };
Aggregate aggregate = new ConcreteAggregate(items);
for (Iterator iter = aggregate.getIterator(); iter.hasNext();) {
String item = (String) iter.next();
System.out.println(item);
}
}
}
public interface Aggregate {
Iterator getIterator();
}
public class ConcreteAggregate implements Aggregate {
private String items[];
public ConcreteAggregate(String[] items) {
this.items = items;
}
@Override
public Iterator getIterator() {
return new ConcreteIterator(items);
}
}
public interface Iterator {
public boolean hasNext();
public Object next();
}
public class ConcreteIterator implements Iterator {
private String items[];
private int index;
public ConcreteIterator(String[] items) {
this.items = items;
}
@Override
public boolean hasNext() {
if (index < items.length) {
return true;
}
return false;
}
@Override
public Object next() {
if (this.hasNext()) {
return items[index++];
}
return null;
}
}
Output
Item A
Item B
Item C
Item D
