Stack简单实现向下增长数组版

格式和ArrayList类似，只是删除了一些不必要的方法。

public class LowStack<AnyType> {

    private static final int DEFAULT_CAPACITY=10;//定义初始长度

    private int theSize;//当前位置

    private AnyType[] theItems;

    public LowStack(){

        doClear();

    }

    public void clear(){

        doClear();

    }

    private void doClear(){

        theSize=0;

        ensureCapacity(DEFAULT_CAPACITY);

    }

    public int size(){

        return theSize;

    }

    public boolean isEmpty(){

        return size()==0;

    }

    public void trimToSize(){//设置数组长度刚好为当前所用长度

        ensureCapacity(size());

    }

    public AnyType peek(){//返回栈底元素

        if(size()>0){

        return theItems[size()-1];

        }else{

            return null;

        }

    }

    @SuppressWarnings("unchecked")

    public void ensureCapacity(int newCapacity){//重新分配存储单元

        if(newCapacity<theSize)

            return ;

        AnyType[] old=theItems;

        theItems=(AnyType[])new Object[newCapacity];//泛型数组的创建时非法的

        for(int i=0;i<size();i++)//重新赋值

            theItems[i]=old[i];

    }

    public boolean push(AnyType x){

        add(size(),x);

        return true;

    }

    public void add(int idx,AnyType x){

        theItems[idx]=x;

        theSize++;

    }

    public AnyType pop(){

        AnyType removedItem=theItems[size()-1];

        theSize--;

        return removedItem;

    }
}

测试用例

//        LowStack<Integer> a=new LowStack<>();

//        a.push(1);

//        a.push(2);

//        a.push(3);

//        a.push(4);

//        System.out.println(a.peek());

//        while(!a.isEmpty()){

//            System.out.println(a.pop());

//        }