栈的顺序存储结构

栈是一种特殊的线性表，这种线性表只能在固定一端进行插入、删除操作。

栈的常用操作：

初始化：通常是一个构造器，创建一个空栈；

返回栈的长度：返回栈中的元素个数；

入栈：向栈的栈顶插入一个元素，栈的长度+1；

出栈：从栈的栈顶删除一个元素，栈的长度-1，返回被删除的元素；

访问栈顶的元素：

判断栈是否为空：

清空栈：

package MyJava2;

import java.util.Arrays;

public class SequenceStack {
    private int DEFAULT_SIZE=10;
    private int capacity;
    private String[] elements;
    private int size=0;
    
    public SequenceStack(){
        capacity=DEFAULT_SIZE;
        elements=new String[capacity];
    }
    public SequenceStack(String data){
        capacity=DEFAULT_SIZE;
        elements=new String[capacity];
        elements[0]=data;
        size++;
    }
    public SequenceStack(String data,int initlize){
        capacity=1;
        while(capacity<initlize){
            capacity<<=1;
        }
        elements=new String[capacity];
        elements[0]=data;
        size++;
    }

    public void push(String data){
        ensureCapacity(size+1);
        elements[size++]=data;
    }
    private void ensureCapacity(int minCapacity) {
        while (capacity<minCapacity){
            capacity<<=1;
        }
        elements= Arrays.copyOf(elements,capacity);
    }

    public String pop(){
        String old=elements[size-1];
        elements[--size]=null;
        return old;
    }

    public String peek(){
        return elements[size-1];
    }

    public boolean empty(){
        return size==0;
    }

    public void clear(){
        Arrays.fill(elements,null);
    }

    public String toString(){
        StringBuffer sb=new StringBuffer();
        for(int i=0;i<size;i++){
            sb.append(elements[i]+",");
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        SequenceStack stack=new SequenceStack();
        stack.push("A");
        stack.push("B");
        stack.push("C");
        System.out.println(stack.toString());
        System.out.println(stack.size);
        System.out.println(stack.empty());
        System.out.println(stack.peek());
        System.out.println(stack.pop());
        System.out.println(stack.peek());
    }


}