迭代器栈（Iterator Stack）

迭代器栈（Iterator Stack）是使用数组实现的栈结构。它支持迭代器（Iterator）遍历栈中的元素。在 Java 语言中，可以使用 Java 的内置数组来实现迭代器栈。

迭代器栈的实现包含一个数组和一个指向栈顶元素的指针。在入栈操作时，我们将元素插入到数组的栈顶位置，并将栈顶指针向上移动；在出栈操作时，我们将栈顶指针向下移动，并返回栈顶元素。在遍历迭代器栈时，我们使用一个指向栈顶的游标，每次移动游标并返回对应位置的元素，直到游标移动到数组底部为止。

以下是一个简单的迭代器栈的实现示例，使用 Java 语言实现：

import java.util.Iterator;

public class IteratorStack<Item> implements Iterable<Item> {
    private Item[] items;
    private int top;

    public IteratorStack(int capacity) {
        this.items = (Item[]) new Object[capacity];
        this.top = 0;
    }

    public boolean isEmpty() {
        return top == 0;
    }

    public void push(Item item) {
        if (top == items.length) {
            resize(2 * items.length);
        }
        items[top++] = item;
    }

    public Item pop() {
        if (isEmpty()) {
            throw new RuntimeException("Stack underflow");
        }
        Item item = items[--top];
        items[top] = null;
        if (top > 0 && top == items.length / 4) {
            resize(items.length / 2);
        }
        return item;
    }

    public Item peek() {
        if (isEmpty()) {
            throw new RuntimeException("Stack underflow");
        }
        return items[top - 1];
    }

    private void resize(int capacity) {
        Item[] copy = (Item[]) new Object[capacity];
        for (int i = 0; i < top; i++) {
            copy[i] = items[i];
        }
        items = copy;
    }

    @Override
    public Iterator<Item> iterator() {
        return new Iterator<Item>() {
            private int current = top - 1;

            @Override
            public boolean hasNext() {
                return current >= 0;
            }

            @Override
            public Item next() {
                if (!hasNext()) {
                    throw new RuntimeException("No more items");
                }
                return items[current--];
            }
        };
    }
}

在上述实现中，我们使用泛型 Item 表示栈中的元素类型。IteratorStack 类包含了 isEmpty、push、pop 和 peek 四个方法，分别用于判断迭代器栈是否为空、入栈、出栈和返回栈顶元素。我们使用泛型数组来存储迭代器栈中的元素，并且在入栈时实现了动态扩容和在出栈时实现了动态缩容。