创建固定大小的堆栈

Question

我想在 Java 中创建一个堆栈，但要固定大小。例如，创建一个新堆栈，将大小设置为 10，然后当我将项目推送到堆栈时，它会填满，当它填满 10 时，堆栈中的最后一个项目被推开（移除）。我想使用 Stack，因为它使用 LIFO 并且非常适合我的需求。

但是 Stack 从 Vector 继承的 setSize() 方法似乎并没有真正限制 Stack 的大小。我想我错过了关于 Stacks 如何工作的一些东西，或者 Stacks 并不意味着受到限制，所以这是不可能的。请教育我！

Answer 1

您可以继承Stack 并覆盖适当的方法来实现此自定义行为。并确保给它一个清晰的名称（例如FixedStack）。

Answer 2

纯堆栈不会限制它的大小，因为堆栈解决的许多问题你不知道你需要多少元素。

您可以编写一个自定义堆栈来实现您所描述的需求。但是，如果这样做，您将打破 LIFO。如果达到最大尺寸，并且您将新的东西压入堆栈，您只会丢失先前添加的项目。因此，如果您随后开始从堆栈中弹出项目，您会错过一些。

Answer 3

您需要的是一个像LinkedList 这样的双端队列。虽然这不会自动将元素放在前面，但通过子类化/装饰它，您可以添加该功能。

Answer 4

这不是不可能的 :) 你只需要提供你自己的实现。

我会从像 this 这样的 RingBuffer 开始并相应地调整它。

Answer 5

您可以像这样创建一个非常简单的堆栈：

public class FixedStack<T>
{
    private T[] stack;
    private int size;
    private int top;

    public FixedStack<T>(int size)
    {
        this.stack = (T[]) new Object[size];
        this.top = -1;
        this.size = size;
    }

    public void push(T obj)
    {
        if (top >= size)
            throw new IndexOutOfBoundsException("Stack size = " + size);
        stack[++top] = obj;
    }

    public T pop()
    {
        if (top < 0) throw new IndexOutOfBoundsException();
        T obj = stack[top--];
        stack[top + 1] = null;
        return obj;
    }

    public int size()
    {
        return size;
    }

    public int elements()
    {
        return top + 1;
    }
}

Answer 6

您可以使用 LinkedHashMap 并覆盖它的 removeEldestEntry 方法：

public class FixedStack extends LinkedHashMap<Long, String> {

    private final int capacity;

    public FixedStack(int capacity) {
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(final Map.Entry<Long, String> eldest) {
        return super.size() > capacity;
    }
}

并对其进行测试：

    public static void main(String[] args) {

        FixedStack stack = new FixedStack(10);

        long added = 0;
        for (Locale locale : Locale.getAvailableLocales()) {
            if (locale.getDisplayCountry().length() > 0) {
                stack.put(added, locale.getDisplayCountry());
                System.out.println(locale.getDisplayCountry());
                added++;
            }
        }
        System.out.println(String.format(">>>>>>>>> %s added",
                added));
        Iterator<Entry<Long, String>> iterator = stack.entrySet().iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().getValue());
        }
    }

您只需要决定要使用什么作为键，我在示例中使用了一个简单的计数器。

Answer 7

这是一个扩展 Stack 的 SizedStack 类型：

import java.util.Stack;

public class SizedStack<T> extends Stack<T> {
    private int maxSize;

    public SizedStack(int size) {
        super();
        this.maxSize = size;
    }

    @Override
    public T push(T object) {
        //If the stack is too big, remove elements until it's the right size.
        while (this.size() >= maxSize) {
            this.remove(0);
        }
        return super.push(object);
    }
}

像这样使用它：Stack<Double> mySizedStack = new SizedStack<Double>(10);。除了大小之外，它的运行方式与任何其他 Stack 一样。