采用泛型，自己实现一个Stack

实现思路：

1.建立一个结点，每个结点都有一个保存自身value的属性，以及一个指向下一个结点的ref.

2.当前Stack指向一个结点

3.put方法，每次都新创建这样的一个结点，把值放进去，然后把指向下一个结点的ref，用来指向当前的stack所指向的那个结点

4.pop方法，返回当前stack指向的那个结点的value. 并把当前结点所引用的下一个结点，作为当前结点。


最后测试，pop, put是否能工作，以及内存是否能够回收

这种Stack，比起用List或者数组的Stack的好处在于环保，不会一次性初始化一堆暂时不用的内存。

package general;

public class LinkedStack<T> {
	
	Node<T> stack;

	class Node<N>{
		public T value;
		public Node<T> inside;
		
		//查看是否能够回收对象
		@Override
		protected void finalize() throws Throwable {
			System.out.println("finalize after pop "+value);
		}
		
	}
	
	public T pop(){
		if(stack!=null){
			T value=stack.value;
			stack=stack.inside;
			//System.gc();
			return value;
		}else{
			return null;
		}
	}
	
	public void put(T t){
		Node<T> topNode=new Node<T>();
		topNode.value=t;
		topNode.inside=stack;
		stack=topNode;
	}
	
	public void testMyStack(){
		LinkedStack<Integer> stack=new LinkedStack<Integer>();
		stack.put(1);
		stack.put(2);
		stack.put(3);
		stack.put(4);
		stack.put(5);
		stack.put(6);
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		stack.put(5);
		stack.put(6);
		stack.put(7);
		stack.put(8);
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		
	}
	
	//测试是否能够回收内存
	public void testMemoryClean(){
		LinkedStack<Integer> stack=new LinkedStack<Integer>();
		stack.put(1);
		stack.put(2);
		stack.put(3);
		stack.put(4);
		stack.pop();
	}
	
	public static void main(String args[]){
		new LinkedStack().testMyStack();
	}
}