java泛型编程

package com.genericity;

import org.junit.Test;

/**
* @Title: LinkedListStack.java 
* @Package com.genericity 
* @Description: 编写一个泛型栈（链表式）
* @author lky 
* @date 2015年10月17日 下午8:34:07 
* @version V1.0
 */
public class LinkedListStack<T> {
    
    /**
    * @Title: LinkedListStack.java 
    * @Package com.genericity 
    * @Description:定义栈中的节点类型
    * @author lky 
    * @date 2015年10月17日 下午8:38:51 
    * @version V1.0
     */
    private static class Node<U>{
        U item;
        Node<U> next;
        
        Node(){
            this.item=null;
            this.next=null;
        }
        Node(U item,Node<U>next){
            this.item=item;
            this.next=next;
        }
        
        boolean isEmpty(){
            return item==null && next==null;
        }
        
    }
    
    private Node<T> top=new Node<T>();//栈顶指针
    
    public void push(T item){  //入栈
        top=new Node<T>(item,top);
    }
    
    public T pop(){    //出栈
        T result=top.item;
        if(!top.isEmpty()){
            top=top.next;
        }
        return result;
    }
    
    
}

package com.genericity;

import org.junit.Test;

public class testLinkedListStack {
    @Test
    public void testPush(){
        LinkedListStack<String> aLinkedListStack=new LinkedListStack<String>();
        aLinkedListStack.push("lky");
        aLinkedListStack.push("aaaa");
        String res=aLinkedListStack.pop();
        while(res!=null){
            System.out.println(res);
            res=aLinkedListStack.pop();
        }
    }
}

package com.genericity;

import java.util.ArrayList;
import java.util.Date;

import org.junit.Test;

public class GenericMethods  {
    
    /**
    * @Title: getType 
    * @Description: 返回任意数组的数据类型
    * @param item
     */
    public <T> String getType(T item){
        return item.getClass().getName();
    }
    
    @Test
    public void test(){
        System.out.println(new GenericMethods().getType(new Date()));
        System.out.println(new GenericMethods().getType(1));
        System.out.println(new GenericMethods().getType("lky"));
        System.out.println(new GenericMethods().getType(new ArrayList<String>()));
    }
}

package com.genericity;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

import org.junit.Test;

public class New {

    public <k, v> Map<k, v> map() {
        return new HashMap<k, v>();
    }

    public <T> List<T> list() {
        return new ArrayList<T>();
    }

    public <T> LinkedList<T> linkList() {
        return new LinkedList<T>();
    }

    public <T> Set<T> set() {
        return new HashSet<T>();
    }

    public <T> Queue<T> queue() {
        return new LinkedList<T>();
    }
    
    @Test
    public void test(){
        New new1=new New();
        Map<String, LinkedList<String>> lisMap=new1.map();
    }
}

package com.genericity;

import java.util.HashSet;
import java.util.Set;

import org.junit.Test;


public class Sets {
    
    /**
    * @Title: union 
    * @Description: 集合的并集
    * @throws
     */
    public static <T> Set<T> union(Set<T> a,Set<T> b){
        Set<T> set=new HashSet<T>(a);
        set.addAll(b);
        return set;
    }
    
    /**
    * @Title: intersetion 
    * @Description: 集合交集
     */
    public static <T> Set<T> intersetion(Set<T>a,Set<T> b){
        Set<T> set=new HashSet<T>(a);
        set.retainAll(b);
        return set;
        
    }
    /**
    * @Title: difference 
    * @Description: 集合差集
     */
    public static <T> Set<T> difference(Set<T>a, Set<T> b){
        Set<T> set=new HashSet<T>(a);
        set.removeAll(b);
        return set;
    }
    
    public static <T> Set<T> complement(Set<T>a,Set<T> b){
       return  difference(union(a, b), intersetion(a, b));
    }
    
    
    @Test
    public void test(){
        HashSet<Integer> a=new HashSet<Integer>();
        HashSet<Integer> b=new HashSet<Integer>();
        for(int i=0;i<8;++i){
            if(i<5)a.add(i);
            if(i>2) b.add(i); 
        }
        
        System.out.println(union(a, b).toString());
        System.out.println(difference(a, b).toString());
        System.out.println(intersetion(a, b).toString());
        System.out.println(complement(a, b).toString());
    }
    
}