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