Java数组实现栈：清空方法的高效选型（速度与内存考量）

public class ArrayBasedStack<T> implements StackInterface<T> {

    private static final int INITIAL_CAPACITY = 5;

    private T[] data;
    private int topOfStack;

    public ArrayBasedStack() {
        this(INITIAL_CAPACITY);
    }

    public ArrayBasedStack(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException("Array initial size error.");

        this.data = (T[]) new Object[capacity];
        this.topOfStack = -1;
    }

    @Override
    public void push(T newEntry) {
        if (isArrayFull()) expandArray();
        data[++topOfStack] = newEntry;
    }

    @Override
    public T pop() {
        if (isEmpty()) throw new EmptyStackException();
        T item = data[topOfStack];
        data[topOfStack--] = null;
        return item;
    }

    @Override
    public T peek() {
        if (isEmpty()) throw new EmptyStackException();
        return data[topOfStack];
    }

    @Override
    public boolean isEmpty() {
        return topOfStack < 0;
    }

    @Override
    public void clear() {}

    private void expandArray() {
        int doubledSizeOfData = data.length * 2;
        data = Arrays.copyOf(data, doubledSizeOfData);
    }

    private boolean isArrayFull() {
        return topOfStack >= data.length - 1;
    }
}

针对你提出的三种clear实现方式，从速度、内存效率和适用场景三个维度拆解如下：

1. 将topOfStack设为-1 #

• 速度：最快的实现，时间复杂度O(1)，仅需修改一个整数变量，无额外操作。
• 内存：数组容量保持不变，旧元素的引用仍留在数组中。如果后续复用该栈，无需重新扩容，能节省push时的扩容开销；若栈不再使用，数组占用的内存会随栈对象被GC回收，旧元素也会被处理。
• 适用场景：绝大多数常规场景的首选，尤其是栈需要反复复用的情况。

2. 重新分配数组 #

• 速度：时间复杂度O(1)，但比第一种稍慢——需要创建新的初始容量数组，再将data引用指向它，原数组会被标记为垃圾等待GC回收。
• 内存：立即释放原数组占用的内存，让栈回到初始容量状态，避免大数组闲置浪费内存。
• 适用场景：适合清空后大概率不再使用，或短期内不会存入大量元素的场景。但如果后续又要存大量数据，会触发多次扩容，增加额外开销。

3. 将数组所有元素设为null #

• 速度：最慢的实现，时间复杂度O(n)（n为数组长度），需遍历整个数组逐个赋值null。
• 内存：立即释放栈内所有元素的引用，使这些对象可被GC回收，但数组本身的容量仍保留。
• 适用场景：仅在需要立即回收元素内存且保留数组容量时考虑——这种场景非常少见，因为第一种方式可通过后续push覆盖旧元素，或等待GC自动处理。

总结选择策略 #

• 优先选方式1：兼顾速度和后续复用效率，是绝大多数场景的最优解。
• 若要节省内存且栈不再复用，选方式2。
• 仅在需要立即回收元素内存且保留数组容量时，才考虑方式3。

内容的提问来源于stack exchange，提问作者Noah