队列是先入先出的结构，这和下压栈的规则一样，实现一个队列和实现一个下压栈很类似，所以我们可以先设定一个变量pointer指向栈顶，将新元素添加到array[pointer]之中，然后对pointer自增，出队的时候，弹出栈顶的元素即可。

可以先设置队列的规则：

public interface IQueue<T> {
    void push(T item);
    T pop();
    T peek();
    int size();
    boolean isEmpty();

    void resize(int capacity);

}

在添加和删除的时候，需要判断数组的非空元素的个数，对数组做对应的resize：
1.push的时候，如果pointer == array.length,就将数组的容量扩充一倍
2.pop的时候，如果pointer == array.length / 4,就将数组的容量减少一半

队列的具体代码如下：

public class ArrayQueue<T> implements IQueue<T> {

    private T[] items;
    private int pointer;//指向栈顶


    public T ArrayQueue() {
        this.items = (T[]) new Object[10];
    }


    @Override
    public void push(T item) {

        if(pointer == items.length) resize(2 * items.length);

        items[pointer++] = item;
    }

    @Override
    public T pop() {
        T item = items[pointer - 1];
        //防止对象游离
        items[pointer -1] = null;
        pointer --;

        if(pointer > 0 && pointer == items.length /4) resize(items.length / 2);

        return item;
    }

    /**
     * 出队但不删除
     * @return
     */
    @Override
    public T peek() {
        return items[pointer - 1];
    }

    @Override
    public int size() {
        return pointer;
    }

    @Override
    public boolean isEmpty() {
        return pointer == 0;
    }

    @Override
    public void resize(int capacity) {
        if(capacity >= pointer){
            T[] temp = (T[]) new Object[capacity];

            for(int i = 0; i < capacity; i++){
                temp[i] = items[i];
            }
            items = temp;
        }
    }
}