栈 的java实现

栈的java实现，链栈的实现，其节点的声明方式，与结构体不大相同，只一点需要注意，还有泛型的擦除。使用泛型时，对泛型是不分配内存空间的 ，只是栈中引用指向他，使用new 分配空间的都会在堆中。

/**
 *数组栈的java实现
 */
class ArrayStack<AnyType>{
	private static final int DEFAULT_CAPACITY=10;
	AnyType []array;
	int size;
	int topStack;
	public ArrayStack()
	{
		clear();
		size=0;
	}
	public void push(AnyType x)
	{
		array[++topStack]=x;
		size++;
	}
	/**
	 * 再取出栈顶元素时先判断是否为空；
	 */
	public AnyType top()
	{
		if(topStack==-1)
			return null;
		 return array[topStack];
	}
	public AnyType pop()
	{
		if(topStack==-1)
			return null;
		size--;
		return array[topStack--];
	}
	public void clear()
	{
		topStack=-1;
		ensureCapacity(DEFAULT_CAPACITY);
	}
	private void ensureCapacity(int defaultCapacity)
	{
		if(size>defaultCapacity)
			return ;
		//注意这里只能够创建object类型，然后再强制类型转换，因为泛型有类型
		//擦除，用new T创建了 也不知道T的确切类型,不能识别AnyType
        AnyType newArray[]=(AnyType[])new Object[defaultCapacity];
        for(int i=0;i<size;i++)
        	newArray[i]=array[i];
        array=newArray;
	}
	public int size()
	{
		return size;
	}
}
class LinkedStack<AnyType>{
	private static class Node<AnyType>{
		public AnyType e;
		public Node<AnyType> pre;
		public Node(AnyType e,Node<AnyType> pre){
			this.e=e;
			this.pre=pre;
		}
	}
	private Node<AnyType> top;
    int size;
	public  LinkedStack(){
		clear();
		
	}
	public void clear()
	{
		size=0;
		top=new Node<AnyType>(null,null);
	}
	public AnyType top()
	{
		return top.e;
	}
	public void push(AnyType e)
	{
		top=new Node<AnyType>(e, top);
		size++;
	}
	public  int size(){
		return size;
	}
	public AnyType pop()
	{
		if(isEmpty())
			return null;
		AnyType a=top.e;
		size--;
		top=top.pre;
		return a;
	}
	public boolean isEmpty()
	{
		if(size==0)
			return true;
		return false;
	}
}
public class TestStack {
    public static void main(String args[])
    {
    	LinkedStack<Integer>a=new LinkedStack<Integer>();
    	a.push(2);
    	a.push(3);
    	a.push(4);
    	System.out.println(a.size()+" ");
    	System.out.println(a.pop()+" ");
    	System.out.println(a.size()+" ");
    }