教你如何使用Java泛型

泛型（ Generic）实现了参数化类型的概念，使得代码可以应用于多种类型。我们常用的ArrayList<T>，HashMap<K,V>等都是使用了泛型。泛型的意思就是可以适用于许多种的类型。
Java的核心概念就是：告诉编译器想使用什么类型，然后编译器帮你处理一切细节。

泛型类

我们最常见的就是泛型类了，比如我们上面提到的ArrayList<T>，HashMap<K,V>等等。下面我们以一个具体的例子，看看如何创建一个自己的泛型类。
创建一个堆栈类，实现简单的入栈和出栈操作。

package genericdemo.classdemo;


/**
 * 利用泛型实现一个简单的堆栈类
 * @author nxiangbo
 *
 * @param <T>
 */
public class LinkedStack<T> {
    /**
     * 内部类Node是一个泛型。
     * @author nxiangbo
     * 
     * @param <E>
     */
    private static class Node<E>{
        E item;
        Node<E> next;
        public Node() {
            item = null;
            next = null;
        }
        public Node(E item, Node<E> next){
            this.item = item;
            this.next = next;
        }

        private boolean end() {
            return (item==null)&&(next==null);
        }
    }

    private Node<T> top = new Node<T>();

    /**
     * 入栈
     * @param item
     */
    public void push(T item){
        top = new Node<T>(item, top); 
    }

    /**
     * 出栈
     * @return
     */
    public T pop(){
        T result = top.item;
        if(!top.end()){
            top = top.next;
        }
        return result;
    }

}

下面测试一下上述泛型类如何使用的。

public static void main(String[] args) {
        //String 类型的
        LinkedStack<String> lsStr = new LinkedStack<String>();
        String strs = "this is generic demo";
        for (String string : strs.split(" ")) {
            lsStr.push(string);
        }

        System.out.println(lsStr.pop());

        //int类型的
        LinkedStack<Integer> lsInt  = new LinkedStack<>();
        int[] nums = {12,43,54,23,43,12345};
        for (int i : nums) {
            lsInt.push(i);
        }

        System.out.println(lsInt.pop());

泛型接口

泛型接口
泛型也可以应用于接口。例如生成器（Generator），这是一种专门负责创建对象的类。实际上这是工厂方法设计模式中的一种应用。
一般而言，一个生成器只定义一个方法，该方法用于产生新的对象。
接口的定义

package genericdemo.interfacedemo;

/**
 * 泛型接口
 * @author nxiangbo
 *
 */
public interface Generator<T> {
    //返回的是参数类型`T`
    T next();
}

那么，该如何使用泛型接口呢？？
我们以斐波那契数为例子，来说明一下，泛型接口如何使用。

public class Fibonacci implements Generator<Integer>{
    private int count = 0;
    private int fib(int n){
        if(n <2){
            return 1;
        }
        return fib(n-2)+fib(n-1);
    }

    @Override
    public Integer next() {

        return fib(count++);
    }

    public static void main(String[] args) {
        Fibonacci finGen = new Fibonacci();
        for (int i = 0; i < 8; i++) {
            System.out.print(finGen.next()+", ");
        }
    }
}

by the way，基本类型无法做为类型参数。比如上面的Generator<Integer>，不能写成Generator<int>, 以及ArrayList<Integer>，不能写成ArrayList<int>等等。

泛型方法

到目前为止，我们都是将泛型应用在类中，但也可以在类中包含参数化方法，而这个方法可以是泛型类，也可以不是泛型类。

泛型方法使得该方法能够独立于类而产生变化。一个基本原则是：无论何时，只要能够使用泛型，就应该尽量使用泛型。如果使用泛型方法可以取代泛型类，那么就应该只使用泛型方法。另外，对于一个static方法，无法访问泛型类的类型参数，所以，如果static方法需要使用泛型能力，就必须使用泛型方法。
泛型方法的定义：只需将泛型参数列表置于返回值之前。
泛型方法与泛型类不同的是： 泛型类在被使用时，必须指明参数类型。而泛型方法在被使用时，不必指明参数类型，因为编译器会为我们找出具体的类型，这称为类型参数推断（type argument inference）。
对于泛型类，由于编译器不能够从泛型参数列表中的一个参数推断出另一个参数。所以，我们每次使用Map等泛型时，必须这样，Map<String,String> map = new HashMap<String,String>。增加了很多的代码。因此，我们可以使用泛型方法构建一个工具类，用以简化泛型类的使用。
代码如下。

package genericdemo.methoddemo;

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

/**
 * 泛型方法
 * 可作为一个工具类，去简化HashMap<K,V>泛型的使用
 * @author nxiangbo
 *
 */
public class New {
    public static <K,V> Map<K, V> map(){
        return new HashMap<K, V>();
    }

    public static <T> java.util.List<T> list(){
        return new ArrayList<T>();
    }

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

    public static <T> Queue<T> queue(){
        return new LinkedList<>();
    }

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

有了这个工具类后，我们就可以很简单的声明泛型了。
具体使用如下。

public static void main(String[] args) {
        Map<String, String> map = New.map();
        java.util.List<String> list = New.list();
        LinkedList<String> linkedList = New.linkedList();
    }

下面我们再看一个关于泛型方法的例子。利用泛型方法，实现集合的并、交、补、差集的工具类。
代码如下。

package genericdemo.methoddemo;

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

/**
 * Sets工具类，实现集合的并、交、差、补集
 * @author nxiangbo
 *
 */
public class Sets {
    /**
     * 并集
     * @param set1
     * @param set2
     * @return
     */
    public static <T> Set<T> union(Set<T> set1, Set<T> set2){
        Set<T> result = new HashSet<T>(set1);
        result.addAll(set2);
        return result;
    }

    /**
     * 交集
     * @param set1
     * @param set2
     * @return
     */
    public static <T> Set<T> intersection(Set<T> set1, Set<T> set2){
        Set<T> result = new HashSet<T>(set1);
        result.retainAll(set2);
        return result;
    }

    /**
     * 差集
     * @param set1
     * @param set2
     * @return
     */
    public static <T> Set<T> difference(Set<T> set1, Set<T> set2){
        Set<T> result = new HashSet<T>(set1);
        result.removeAll(set2);
        return result;
    }

    /**
     * 补集
     * @param set1
     * @param set2
     * @return
     */
    public static <T> Set<T> complement(Set<T> set1, Set<T> set2){
        return difference(union(set1, set2), intersection(set1, set2));
    }


}

测试如下。

public static void main(String[] args) {
        Set<String> set1 = new HashSet<String>();
        set1.add("hash");
        set1.add("map");
        set1.add("list");

        Set<String> set2 = new HashSet<String>();
        set2.add("hash");
        set2.add("array");
        set2.add("list");

        System.out.println(union(set1, set2));
        System.out.println(intersection(set1, set2));
        System.out.println(difference(set1, set2));
    }