effective java 第27条 优先考虑泛型方法

最简单的使用:

    public static <E> Set<E> union(Set<E> s1,Set s2){
        Set<E> result = new HashSet<>(s1);
        result.addAll(s2);
        return result;
    }

这是最简单的使用，不会出现警告和错误，通用性也强。

相关模式是泛型单例工厂。有时，会创建不可变但又适合于许多不同类型的对象。由于泛型是通过擦除实现的，可以给所有必要的类型参数使用单个对象，但是需要编写一个静态工厂的方法，重复地给每个必要的类型参数分发对象。这种模式最常用于函数对象。

public interface UnaryFunction<T> {
    T apply(T arg);
}

 private static final UnaryFunction<Object>  IDENTITY_FUNCTION = new UnaryFunction<Object>(){
       @Override
       public Object apply(Object arg) {
           return arg;
       }
   };

   public static <T> UnaryFunction<T> identityFunction(){
       return (UnaryFunction) IDENTITY_FUNCTION;
   }

    public static void main(String[] args) {
        String[] strings = {"123","456","789"};
        UnaryFunction<String> someString = identityFunction();
        Arrays.asList(strings).forEach(i-> System.out.println(someString.apply(i)));

       Number[] numbers = {1,0.1d,3l};
        UnaryFunction<Number> someNumber = identityFunction();
        Arrays.asList(numbers).forEach(n -> System.out.println(someNumber.apply(n)));

    }

UnaryFunction<T>总是安全的，这是一个关口，而内部使用的object ,这是无所谓的

在做一些操作的时候，需要参数具备一定的条件，比如求取最大值，需要参数具备比较性.使用泛型可以轻松实现：

public static <T extends Comparable<T>> T max(List<T> list){
       Iterator<T> i = list.iterator();
       T result = i.next();
       while(i.hasNext()){
           T t = i.next();
           if(t.compareTo(result) > 0)
               result = t;
       }
       return result;
   }