Java Stack with elements limit

Question

I know this question has asked many times but after seaching for an hour i still have problem.

I want to use a lifo stack which has a max number of elements it can store.After it reach the max number is deletes the element at first place and replace it with the new so in first pop i can get this element and in second i have to get the element at size-1.

What i tried:

1) Using a modified Stack ,as described here .The problem is that it always returning the first 5 elements(if the size is 5) i added.

class StackSizable<E> extends Stack<E>{

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

    @Override
    public E push(E elt) {
        super.push(elt);
        while (this.size() > this.maxSize) {
            this.removeElementAt(this.size() - 1);
        }
        return null;
    }
}

2)Using an ArrayDeque ,i dont see any diference from a simple Stack , its not setting any limit(am i using it wrong?)

ArrayDeque<State> lifo = new ArrayDeque<State>(5);
lifo.pop();
lifo.push(state);

I want to use this in a puzzle game for undo-redo functionality

Solved: I ended using a fixed size stack as tom said ,mainly for the performance

public class FixedStack<T> {
     private T[] stack;
     private int size;
     private int top;
     private int popBalance = 0;//its used to see if all the elements have been popped

     public FixedStack(T[] stack) {
           this.stack = stack;
           this.top = 0;
           this.size = stack.length;
     }

     public void push(T obj) {
           if (top == stack.length)top = 0;
           stack[top] = obj;
           top++;
           if (popBalance < size - 1)popBalance++;
     }

     public T pop() {

          if (top - 1 < 0)top = size;
          top--;
          T ob = stack[top];
          popBalance--;
          return ob;
     }

     public void clear() {
          top = 0;
     }

     public int size() {
          return size;
     }

     public boolean poppedAll() {
          if (popBalance == -1)return true;
          return false;
     }
}

Answer 1

I think the most efficient way to this is with a fixed array, with size equal to your max # of elements, and an index that points to the element that is currently the 'top' of the queue.

When you add a new element you add it at index+1 (wrapping back to element 0 if necessary) and possibly overwriting an element that no longer fits. When you pop an element you do the reverse.

This way your data structure never has to be re-ordered, and you can use an array which is more light-weight then a collection.

Answer 2

When the maximum size has been reached, your line

this.removeElementAt(this.size() - 1);

then immediately removes the last pushed element (which you just pushed), which is the top of the stack. You need to remove the first element instead (bottom of the stack):

this.removeElementAt(0);