列表中特定通用类型的列表

Question

我有一个列表列表。

我想知道如何限制每个内部列表的泛型类型，以便外部列表的每个元素都包含一个只能包含一种对象类型的内部列表。到目前为止，我已经尝试过：

List<ArrayList<?>> l = new ArrayList<ArrayList<?>>();

但是有一些方法可以将对象类型添加到不属于的内部列表中。有没有办法指定内部列表接受的类型？

例如，如果我有以下内部列表，

ArrayList<T1> innerList = new ArrayList<T1>();
ArrayList<T2> innerList2 = new ArrayList<T2>();
ArrayList<T3> innerList3 = new ArrayList<T3>();

如何创建一个外部列表，它可以包含所有内部列表，同时保留内部列表包含的特定类型。

我也不确定这是否可能，或者我所做的是否是糟糕的设计。如果它是糟糕的设计，我们将非常感谢您对更好的设计的洞察（也许有一个不同的系列做得更好）。

Answer 1

这是不可能的。通用信息仅在编译时可用。但是，直到运行时才能知道列表列表的确切内容和结构。因此，编译器不能对每个列表将包含什么做出任何保证。如果您事先知道列表的结构，那么最好考虑一个持有类，例如。

class Holder<T,S> {
    List<T> listOfTs;
    List<S> listOfSs;
}

如果您知道所有列表都将共享一个共同的超类型，那么您可能希望使用通配符边界。

List<List<? extends Shape>> list = new ArrayList<List<? extends Shape>>();
list.add(new ArrayList<Circle>());
list.add(new ArrayList<Square>());

这将允许您根据它们的超类型来操作列表。通配符限制的问题是您不能将任何元素添加到通配符限制的集合中。

考虑以下几点：

List<? extends Shape> list = new ArrayList<Circle>();
list.add(new Square()); 
// element is a valid shape, but not a valid circle 
// contract of the original list is broken.

如果您知道自己只会使用一定数量的泛型，则可以存储每个泛型所代表的类，并使用它以类型安全的方式转换列表。

class ListHolder<T> {
    private final Class<T> clazz;
    private final List<T> list;

    public ListHolder(Class<T> clazz) {
        this.clazz = clazz;
        this.list = new ArrayList<T>();
    }

    public boolean isCircleList() {
        return this.clazz == Circle.class;
    }

    public List<Circle> getCircleList() {
        if (!isCircleList()) {
             throw new IllegalStateException("list does not contain circles");
        }
        return (List<Circle>) list;
    }

    public boolean isRectangleList() {
        return this.clazz == Rectangle.class;
    }

    public List<Rectangle> getRectangleList() {
        if (!isRectangleList()) {
             throw new IllegalStateException("list does not contain rectangles");
        }
        return (List<Rectangle>) list;
    }

    public static void main(String[] args) {
        ListHolder<Rectangle> rectangleListHolder = new ListHolder<Rectangle>(Rectangle.class );

        List<ListHolder<? extends Shape>> list = new ArrayList<ListHolder<? extends Shape>>();

        list.add(rectangleListHolder);

        ListHolder<? extends Shape> shapeWildCardList = list.get(0);

        List<Rectangle> rectangles = shapeWildCardList.getRectangleList();
    }
}

Answer 2

如果您有固定数量的类型可以进入此类列表，您可以为每个类型创建一个子类型。这还有一个好处是您可以使用 instanceof 来确定列表的类型，如果您有一个不同类型列表的列表，您可能想要这样做。

// common supertype for the lists
abstract class SpecialList<T> extends LinkedList<T> {}

// a list for every type:
class T1List extends SpecialList<T1> {}
class T2List extends SpecialList<T2> {}
class T3List extends SpecialList<T3> {}


//use
List<SpecialList<?>> l = new ArrayList<SpecialList<?>>(); 

Answer 3

如果内部列表的类型没有共同点，则无法缩小范围，通配符?是最好的。

如果T1 T2 和T3 都是从基类B 扩展而来，那么你可以这样写：

List<List<? extends B>> outerList = new ArrayList<List<? extends B>>();

或者如果他们共享一个界面。这取决于他们正在实现哪些通用功能需要将它们存储在同一个列表中。

如果您需要设计方面的帮助，您需要通过示例/用例来说明您的情况。如果它们没有任何共同之处，将它们放在同一个集合中可能不是一个好的设计。