Java泛型(3)：泛型方法

泛型还可以同样运用在方法。是否拥有泛型方法与其所在的类是否是泛型类没有关系。

无论何时，只要你能做到，都应该尽量使用泛型方法，如果泛型方法可以取代将整个类整个类泛型化，那么就应该只使用泛型方法。

下面是几个泛型方法的例子。

(1) 利用泛型方法和可变参数列表为List添加元素

 import java.util.ArrayList;
 import java.util.List;

 public class GenericVarargs {
     @SafeVarargs
     public static <T> List<T> make(T... args) {
         List<T> result = new ArrayList<T>();
         for (T arg : args) {
             result.add(arg);
         }
         return result;
     }
 }

         // 利用泛型方法和可变参数列表为List添加元素。
         List<Integer> result = GenericVarargs.make(1, 2, 3);
         System.out.println(result.get(0) + "/" + result.get(1) + "/" + result.get(2)); // 1/2/3

(2) 一个更通用的对象生成器例子，可以为任何类构造一个Generator，以便用next()更方便批量生成对象

 public interface Generator<T> {
     T next();
 }

 public class GenerateObject<T> implements Generator<T> {

     private Class<T> type;

     private GenerateObject(Class<T> type) {
         this.type = type;
     }

     @Override
     public T next() {
         try {
             return type.newInstance();
         } catch (InstantiationException | IllegalAccessException e) {
             throw new RuntimeException(e);
         }
     }

     public static <T> GenerateObject<T> create(Class<T> type) {
         return new GenerateObject<T>(type);
     }
 }

 public class CountedObject {

     private static int count = 0;

     private final long id = ++count;

     public String toString() {
         return "CountedObject " + id;
     }
 }

         // 一个更通用的对象生成器例子，可以为任何类构造一个Generator，以便更方便批量生成对象
         Generator<CountedObject> gen = GenerateObject.create(CountedObject.class);
         for (int i = 0; i < 3; i++) {
             System.out.println(gen.next());
             // CountedObject 1
             // CountedObject 2
             // CountedObject 3
         }

(3) 一个Set的实用工具，可以模拟数学中交集并集的处理

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

 public class SetUtils {

     // 两个Set取并集
     public static <T> Set<T> union(Set<T> a, Set<T> b) {
         Set<T> result = new HashSet<T>(a);
         result.addAll(b);
         return result;
     }

     // 两个Set取交集
     public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
         Set<T> result = new HashSet<T>(a);
         result.retainAll(b);
         return result;
     }

     // 从MainSet减去SubSet
     public static <T> Set<T> difference(Set<T> mainset, Set<T> subset) {
         Set<T> result = new HashSet<T>(mainset);
         result.removeAll(subset);
         return result;
     }

     // 取不在交集里的值
     public static <T> Set<T> complement(Set<T> a, Set<T> b) {
         return difference(union(a, b), intersection(a, b));
     }

     // 打印
     public static <T> String printSet(Set<T> set) {
         StringBuilder sb = new StringBuilder();
         Iterator<T> elem = set.iterator();
         while (elem.hasNext()) {
             sb.append(elem.next());
             if (elem.hasNext()) {
                 sb.append(", ");
             }
         }
         return sb.toString();
     }
 }

         // 一个Set的实用工具，可以模拟数学中交集并集的处理
         Set<Integer> set1 = new HashSet<>(GenericVarargs.make(1, 2, 3, 4, 5));
         Set<Integer> set2 = new HashSet<>(GenericVarargs.make(4, 5, 6, 7, 8));
         System.out.println(SetUtils.printSet(SetUtils.union(set1, set2))); // 1, 2, 3, 4, 5, 6, 7, 8
         System.out.println(SetUtils.printSet(SetUtils.intersection(set1, set2))); // 4, 5
         System.out.println(SetUtils.printSet(SetUtils.difference(set1, set2))); // 1, 2, 3
         System.out.println(SetUtils.printSet(SetUtils.difference(set2, set1)));// 6, 7, 8
         System.out.println(SetUtils.printSet(SetUtils.complement(set1, set2))); // 1, 2, 3, 6, 7, 8