栈Stack（一）--- 栈的顺序存储

public class SequenceStack<T> {

	//定长
	private int DEFAULT_SIZE = 10;
	//保存数组的的长度
	private int capacity;
	//增加的长度为？
	private int Increasement = 0;
	//存储栈的数据元素
	Object [] elementData;
	//记录栈的大小
	private int size;
	
	//默认构建
	public SequenceStack(){
		this.capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}
	
	//指定元素初始化数组
	public SequenceStack(T element){
		this.capacity = DEFAULT_SIZE;
		elementData[0] = element;
		size ++;
	}
	
	/**
	 * 以指定元素和指定长度初始化元素
	 * @param element 指定元素
	 * @param initSize  初始化数组长度
	 */
	public SequenceStack(T element, int initSize){
		this.capacity = initSize;
		elementData = new Object[capacity];
		elementData[0] = element;
		size ++;
	}
	
	/**
	 * 
	 * @param element 指定元素
	 * @param initSize 初始化数组长度
	 * @param Increment   增加长度
	 */
	public SequenceStack(T element, int initSize, int Increment){
		this.capacity = initSize;
		this.Increasement = Increasement;
		elementData = new Object[capacity];
		elementData[0] = element;
		size ++;
	}
	
	//返回栈长
	public int length(){
		return size;
	}
	
	//入栈
    public void push(T element){
    	ensure(size + 1);
    	elementData[size ++] = element;
    }

    //确保长度足够大   ---- 改进的地方
	private void ensure(int i) {
		
		if(i > capacity){
			if(Increasement > 0){
				while(capacity < i){
					capacity += Increasement;
				}
			}
				else{
					while(capacity < i){
						capacity <<= 1;
					}
				}
			elementData = Arrays.copyOf(elementData, capacity);
			}
	}
	
	//出栈
	public T pop(){
		T oldData = (T)elementData[size - 1];
		elementData[-- size] = null;
		return oldData;
	}
	
	//返回栈顶元素
	public T peek(){
		return (T)elementData[size - 1];
	}
	
	//判断是否为空
	public boolean empty(){
		return size == 0;
	}
	
	//清空顺序栈
	public void clear(){
		Arrays.fill(elementData, null);
		size = 0;
	}
	
	public String toString(){
		if(size == 0){
			return "[]";
		}
		else{
			StringBuffer sb = new StringBuffer();
			sb.append("[");
			for(int i = size - 1; i >= 0; i --){    //LIFO
				sb.append(elementData[i].toString() + ", ");
			}
			int len = sb.length();
			return sb.delete(len - 2, len).append("]").toString();
		}
	}
}

测试部分和截图：

public static void main(String[] args) {
		SequenceStack<Integer> ss = new SequenceStack<Integer>();
		ss.push(11);
		ss.push(22);
		ss.push(33);
		ss.push(44);
		System.out.println("栈为：" + ss);
		System.out.println("栈顶元素是：" + ss.peek());
		ss.pop();
		System.out.println("删除栈顶后的栈为：" + ss);
		System.out.println("新的栈弹出的元素是：" + ss.pop());
	}