Java实现栈的顺序存储结构情况

由大话数据结构中参考，使用Java实现栈的顺序存储

1.定义一个栈的常见操作接口：stackADT

    public boolean push(Object element);//压栈

    public Object pop();//出栈

    public boolean isEmpty();

    public int size();

    public Object peek();//返回栈顶对象的一个引用

    public String toString();

    public void expand();//扩容成2倍

2.实现stackADT---SequenceStack

    private Object[] array;//存储元素的容器,初始化为5

    private int top;//指示栈顶位置元素所在位置；索引


    public SequenceStack() {
        array = new Object[5];
        top = -1;
    }

    /**
     * 压栈：向栈顶添加元素
     *
     * @param element
     * @return
     */
    @Override
    public boolean push(Object element) {
        if (top == array.length - 1) {
            expand();
        }
        array[top + 1] = element;
        top += 1;
        return true;
    }


    @Override
    public Object pop() {
        if (top != -1) {
            Object result = array[top];
            array[top] = null;
            top -= 1;
            return result;
        }
        return null;
    }

    @Override
    public boolean isEmpty() {
        return top == -1 ? true : false;
    }

    @Override
    public int size() {
        return top + 1;
    }

    //返回栈顶对象的一个引用
    @Override
    public Object peek() {
        if (!isEmpty()) {
            return array[top];
        }
        return null;
    }

    //扩容成2倍
    @Override
    public void expand() {

        Object[] large = new Object[size() * 2];
        for (int index = 0; index < top + 1; index++) {
            large[index] = array[index];
        }
        array = large;
    }

    public static void main(String[] args) {
        SequenceStack stack = new SequenceStack();

        for (int i = 0; i < 7; i++) {

            stack.push("a" + (i + 1));
        }

        for(int i = 0;i<3;i++){
            stack.pop();
        }
        System.out.println(stack.isEmpty());
        System.out.println("====================");
        System.out.println(stack.peek() + " === " + stack.size());


    }

记录下我的学习路程