第27条：优先考虑泛型方法

如类可以从泛型中受益，方法也一样。静态工具方法尤其适合于泛型化。Collections中所有的方法是泛型化的。

一个返回两个集合的联合的例子：

publlic static Set union(Set s1, Set s2) {
    Set result = new HashSet(s1);
    result.addAll(s2);
    return result;
}

有两条警告，因为使用的是原生态类型Set。

泛型化该方法：

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

不再提示警告，因为它是类型安全的了。

泛型单例工厂：有时候需要创建不可变但又适合于不同类型的对象。

假设有一个接口，只有一个方法，接受和返回某个类型T的值

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

假设要提供一个恒等函数，如果在每次需要的时候都重新创建一个，会很浪费，如果泛型被具体化了，每个类型都需要一个恒等函数，但是它们被擦除之后，就只需要一个泛型单例

private static UnaryFunction<Object> IDENTITY_FUNCTION =
            new UnaryFunction<Object>() {
                @Override
                public Object apply(Object arg) {
                    return arg;
                }
            };
    
    @SuppressWarnings("unchecked")
    public static <T> UnaryFunction<T> indentityFunction() {
        return (UnaryFunction<T>) IDENTITY_FUNCTION;
}

递归类型限制：通过某个包含该类型参数本身的表达式来限制类型参数。

public interface Comparable<T> {
    int compareTo(T o) {
}

类型限制<T extends Comparable<T>> 表示针对可以与自身进行比较的每个类型T

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

该方法在列表中搜索，找出列表中的最大值。