栈的数组实现

package com.algith;

public class MyStack<T> {

private int size;
private T[] elements = null;
private static final int DEFAULT_SIZE = 10;

public MyStack(){
clear();
}

public int size(){
return size;
}

@SuppressWarnings("unchecked")
public void clear(){
size = 0;
elements = (T[]) new Object[DEFAULT_SIZE];
}

public void push(T t){
if(size==elements.length){
ensureCapacity(size*2+1);
}
elements[size++] = t;
}

public T pop(){
if(size<1) return null;
int topIndex = size - 1;
T t = elements[topIndex];
remove(topIndex);
return t;
}

@SuppressWarnings("unchecked")
public void ensureCapacity(int capacity){
if(capacity<size)return;
T[] oldElements = elements;
elements = (T[]) new Object[capacity];
for(int i=0;i<size;i++){
elements[i] = oldElements[i];
}
}

public T remove(int index){
if(index<0||index>size)
throw new ArrayIndexOutOfBoundsException();
T removeValue = elements[index];
for(int i=index;i<size-1;i++){
elements[i] = elements[i+1];
}
size--;
return removeValue;
}

public T get(int index){
if(index<0||index>size)
throw new ArrayIndexOutOfBoundsException();
return elements[index];
}

public T set(int index,T newValue){
if(index<0||index>size)
throw new ArrayIndexOutOfBoundsException();
T oldValue = elements[index];
elements[index] = newValue;
return oldValue;

}

public void print(){
for(int u=0;u<size;u++){
System.out.println(elements[u]+",index"+u);
}
}

public static void main(String[] args) {
MyStack<Integer> stack = new MyStack<Integer>();
for(int i=0;i<10;i++){
stack.push(i+12);
}
System.out.println(stack.size());
System.out.println(stack.remove(1));
System.out.println(stack.size());
System.out.println(stack.pop());
System.out.println(stack.size());
stack.print();
}