Describe the Iterator design pattern and provide an example of its usage.

The Iterator design pattern is a behavioral design pattern that provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. It allows clients to traverse the elements of a collection without knowing the specific implementation details of the collection.

The Iterator pattern consists of three main components: the Iterator interface, the ConcreteIterator class, and the Aggregate interface.

The Iterator interface defines the methods that should be implemented by all iterators. These methods typically include operations like retrieving the next element, checking if there are more elements, and resetting the iterator.

The ConcreteIterator class implements the Iterator interface and provides the actual implementation for traversing the collection. It keeps track of the current position within the collection and provides the necessary methods to move to the next element, retrieve the current element, and check if there are more elements.

The Aggregate interface defines the methods for creating an iterator object. This interface is implemented by the collection classes that want to provide iteration functionality.

Here is an example of how the Iterator pattern can be used:

```java
// Iterator interface
interface Iterator {
boolean hasNext();
Object next();
}

// ConcreteIterator class
class ConcreteIterator implements Iterator {
private String[] collection;
private int position = 0;

public ConcreteIterator(String[] collection) {
this.collection = collection;
}

public boolean hasNext() {
return position < collection.length;
}

public Object next() {
if (this.hasNext()) {
return collection[position++];
}
return null;
}
}

// Aggregate interface
interface Aggregate {
Iterator createIterator();
}

// ConcreteAggregate class
class ConcreteAggregate implements Aggregate {
private String[] collection;

public ConcreteAggregate(String[] collection) {
this.collection = collection;
}

public Iterator createIterator() {
return new ConcreteIterator(collection);
}
}

// Client code
public class Main {
public static void main(String[] args) {
String[] collection = {"Element 1", "Element 2", "Element 3"};

Aggregate aggregate = new ConcreteAggregate(collection);
Iterator iterator = aggregate.createIterator();

while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
```

In this example, we have an array of strings that represents a collection. The ConcreteIterator class provides the implementation for iterating over this collection. The ConcreteAggregate class implements the Aggregate interface and creates an instance of the ConcreteIterator.

The client code creates an instance of the ConcreteAggregate and uses its createIterator method to obtain an iterator object. It then uses the iterator to traverse the collection and print each element.

By using the Iterator pattern, the client code can iterate over the collection without knowing its internal structure or implementation details. This allows for a more flexible and decoupled design.