Java 常见数据结构使用泛型所呈现的便捷之处

Stack 栈 使用泛型 案例：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;



public class MyStack<T>  {
	LinkedList<T> sd=new LinkedList<>();
	public void pull(T t)
	{
		sd.addFirst(t);
	}
	public void peek()
	{
         sd.removeFirst();
	}
	
	public static void main(String[] args) {
		MyStack<Hero> MH=new MyStack<>();
		
		for (int i = 0; i < 10; i++) {
			MH.pull(new Hero("hero-"+i));
		}
		MH.peek();
		System.out.println("Hero Class:"+MH.sd);
		
		MyStack<Hight> hight=new MyStack<>();
		for (int i = 0; i < 10; i++) {
			hight.pull(new Hight("Hight-"+i));
		}
		hight.peek();
		System.out.println("Hight Class:"+hight.sd);
	}
}
	
  

实质为 在MyStack< T > 该类设计的时候，在类的声明上，加上一个< T >，表示该类支持泛型。
如果不添加，那么你在用该类实例化对象的时候 就只能对一种类进行入栈操作 也就是主函数只能操作一种 要想实现另一种 只得新建类
因此添加泛型 可以在主函数 多次实例化不同类型的对象 节省时间

二叉树：
二叉树使用泛型 和之前的代码相差无几 值得注意的是 泛型的添加 实质也是控制了类的类别
案例：

import java.util.*;
public class Node<T> {
    public Node<T> leftNode;
    public Node<T> rightNode;
    public T value;
    
    public void add(T v)
    {
    	if(value==null)
    		value=v;
    	else {
    		if((Integer)v<=(Integer)value)
    		{
    			if(leftNode==null)
    				leftNode=new Node();
                    leftNode.add(v);    			
    		}
    		else
    		{
    			if(rightNode==null)
    				rightNode=new Node();
    			    rightNode.add(v);
    		}
    	}
    }
    public List<T> ordered() {
           List<T> sd=new ArrayList<>();
           if(leftNode!=null)
        	   sd.addAll(leftNode.ordered());
           sd.add(value);
           if(rightNode!=null)
        	   sd.addAll(rightNode.ordered());
           return sd;
    }
    
    public static void main(String[] args) {
		Node<Integer> no=new Node<>();
		for (int i = 0; i < 10; i++) {
			no.add((int)(Math.random()*100));
		}
	
		System.out.println(no.ordered());
	
	}
}

比如public T value; 这里的对于真值的定义 value的类类型就是你所指定的泛型的类类型了 方便之处也同与Stack 一致

其他：
public Class getClazz() 这一句前一个T规定了什么类型的类才可以调用这个方法，后一个T规定了返回值类型。