Java泛型(1)：概述

通常而言，我们使用一种容器来存储一种类型的对象。而泛型的主要目的之一就是用来指定这个容器要持有什么类型的对象。因此，与其使用Object，我们可以暂时不指定类型。

看下面3个例子：

(1) 我们有时候想调用一个方法返回多个返回值，但是又不想单独再创建一个类。我们可以将一组对象直接打包放在一个元组中。这个容器处始化后，只允许读取其中元素，不能再写入(final域)。

public class TwoTuple<A, B> {
    public final A first;
    public final B second;

    public TwoTuple(A first, B second) {
        this.first = first;
        this.second = second;
    }
}

public class ThreeTuple<A, B, C> extends TwoTuple<A, B> {
    public final C third;

    public ThreeTuple(A first, B second, C third) {
        super(first, second);
        this.third = third;
    }
}

public class TupleUtils {

    public static <A, B> TwoTuple<A, B> initTuple(A a, B b) {
        return new TwoTuple<A, B>(a, b);
    }

    public static <A, B, C> ThreeTuple<A, B, C> initTuple(A a, B b, C c) {
        return new ThreeTuple<A, B, C>(a, b, c);
    }
    // four five ...
}

Main方法测试：

        TwoTuple<Integer, String> twoTuple = TupleUtils.initTuple(1, "aaa");
        ThreeTuple<Integer, String, String> threeTuple = TupleUtils.initTuple(2, "bb", "cc");
        System.out.println(twoTuple.first + "/" + twoTuple.second); // 1/aaa
        System.out.println(threeTuple.first + "/" + threeTuple.second + "/" + threeTuple.third); // 2/bb/cc

 

(2) 一个自己实现的泛型堆栈例子(模拟链表实现)

public class LinkStack<T> {
    private class Node<U> {
        U item;
        Node<U> next; // 相当于一个指针

        Node() {
        }

        Node(U item, Node<U> next) {
            this.item = item;
            this.next = next;
        }

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

    // 末断哨兵，这个指针总是指向栈顶
    private Node<T> top = new Node<T>();

    public LinkStack<T> push(T item) {
        top = new Node<T>(item, top);
        return this;
    }

    public T pop() {
        T result = top.item;
        if (!top.isEnd()) {
            top = top.next;
        }
        return result;
    }
}

Main方法测试：

        LinkStack<Integer> stack = new LinkStack<>();
        stack.push(1).push(2).push(3);
        System.out.println(stack.pop() + "/" + stack.pop() + "/" + stack.pop() + "/" + stack.pop()); // 3/2/1/null

 

(3) 一个随机取对象的容器类

public class RandomList<T> {

    public final List<T> storage;

    private Random ran;

    public RandomList(List<T> storage) {
        if (storage == null || storage.size() == 0) {
            throw new RuntimeException("List must not be empty!");
        }
        this.storage = storage;
        // 不设定种子。种子相同，即使实例不同也产生相同的随机数。
        ran = new Random();
    }

    public T select() {
        if (storage.size() == 0) {
            return null;
        }
        // 随机的int值，介于[0,n)的区间
        int pos = ran.nextInt(storage.size());
        T result = storage.get(pos);
        storage.remove(pos);
        return result;
    }
}

Main方法测试：

        // Arrays.asLisvt()返回java.util.Arrays$ArrayList，而不是ArrayList。
        // Arrays$ArrayList和ArrayList都是继承AbstractList，但是remove，add等method在AbstractList中是默认throw UnsupportedOperationException。
        // 所以不能用以下写法。
        // List<Integer> dataList = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> dataList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        RandomList<Integer> ranList = new RandomList<>(dataList);
        System.out.println(ranList.select() + "/" + ranList.select() + "/" + ranList.select() + "/" + ranList.select()
                + "/" + ranList.select() + "/" + ranList.select()); // 4/2/5/3/1/null(一种结果)