如何使java函数获取任何类的对象列表

我正在尝试编写一个Java函数，它接受一个包含any类对象的

List

s，然后计算由所有不同的内部列表对象组合组成的集合的大小，其中所有对象来自不同的列表。算法很简单：

int combos(List<List<Object>> inList) {
    int res = 1;
    for(List<Object> list : inList) {
        res *= list.size();
    }
    return res;
}

int组合（列表中的列表）{
int res=1；
用于（列表：inList）{
res*=list.size（）；
}
返回res；
}

但我在尝试使用

列表

对象作为输入参数运行函数时遇到此错误：

List<List<Integer>> input = new ArrayList<List<Integer>>();
input.add(new ArrayList<Integer>());
input.get(0).add(1);
input.get(0).add(2);
combos(input);

<T> int combos(List<List<T>> inList) {
    int res = 1;
    for(List<T> list : inList) {
        res *= list.size();
    }
    return res;
}

List input=new ArrayList（）；
add（newarraylist（））；
输入。获取（0）。添加（1）；
输入。获取（0）。添加（2）；
组合（输入）；

错误：

The method combos(List<List<Object>>) in the type SpellChecker is not applicable for the arguments (List<List<Integer>>)

类型拼写检查器中的方法组合（列表）不适用于参数（列表）

---

据我所知，

Object

是

Integer

的父类。那么为什么这不起作用呢？如何使其工作？

对象和整数之间的关系不适用于列表和列表，有关详细信息，请参见例如

使用类型参数：

List<List<Integer>> input = new ArrayList<List<Integer>>();
input.add(new ArrayList<Integer>());
input.get(0).add(1);
input.get(0).add(2);
combos(input);

<T> int combos(List<List<T>> inList) {
    int res = 1;
    for(List<T> list : inList) {
        res *= list.size();
    }
    return res;
}

int组合（列表中的列表）{
int res=1；
用于（列表：inList）{
res*=list.size（）；
}
返回res；
}

对象和整数之间的关系不适用于列表和列表，有关详细信息，请参见示例

使用类型参数：

List<List<Integer>> input = new ArrayList<List<Integer>>();
input.add(new ArrayList<Integer>());
input.get(0).add(1);
input.get(0).add(2);
combos(input);

<T> int combos(List<List<T>> inList) {
    int res = 1;
    for(List<T> list : inList) {
        res *= list.size();
    }
    return res;
}

int组合（列表中的列表）{
int res=1；
用于（列表：inList）{
res*=list.size（）；
}
返回res；
}

一种解决方案是在组合中使用类型参数：

<T> int combos(List<List<T>> inList) {
    int res = 1;
    for(List<T> list : inList) {
        res *= list.size();
    }
    return res;
}

int组合（列表中的列表）{
int res=1；
用于（列表：inList）{
res*=list.size（）；
}
返回res；
}

一种解决方案是在组合中使用类型参数：

<T> int combos(List<List<T>> inList) {
    int res = 1;
    for(List<T> list : inList) {
        res *= list.size();
    }
    return res;
}

int组合（列表中的列表）{
int res=1；
用于（列表：inList）{
res*=list.size（）；
}
返回res；
}

这与关于嵌套泛型密切相关。这个问题的答案提供了一些很好的信息

除了你已经得到的两个好答案之外，还有另一个选择

public static void main(String[] args) {
    List<List<Integer>> input = new ArrayList<>();
    input.add(new ArrayList<>());
    input.get(0).add(1);
    input.get(0).add(2);
    combos(input);
}

static int combos(List<? extends List<?>> inList) {
    int res = 1;
    for (List<?> list : inList) {
        res *= list.size();
    }
    return res;
}

publicstaticvoidmain（字符串[]args）{
列表输入=新的ArrayList（）；
add（newarraylist（））；
输入。获取（0）。添加（1）；
输入。获取（0）。添加（2）；
组合（输入）；
}
静态int组合（列表>inList）{
int res=1；
用于（列表：inList）{
res*=list.size（）；
}
返回res；
}

这与关于嵌套泛型密切相关。这个问题的答案提供了一些很好的信息

除了你已经得到的两个好答案之外，还有另一个选择

public static void main(String[] args) {
    List<List<Integer>> input = new ArrayList<>();
    input.add(new ArrayList<>());
    input.get(0).add(1);
    input.get(0).add(2);
    combos(input);
}

static int combos(List<? extends List<?>> inList) {
    int res = 1;
    for (List<?> list : inList) {
        res *= list.size();
    }
    return res;
}

publicstaticvoidmain（字符串[]args）{
列表输入=新的ArrayList（）；
add（newarraylist（））；
输入。获取（0）。添加（1）；
输入。获取（0）。添加（2）；
组合（输入）；
}
静态int组合（列表>inList）{
int res=1；
用于（列表：inList）{
res*=list.size（）；
}
返回res；
}

如果不需要将列表数据类型专门化为

List

List input=new ArrayList（）；
add（newarraylist（））；
input.get（0）.add（新整数（1））；
input.get（0）.add（新整数（2））；
组合（输入）；

如果不需要将列表数据类型专门化为

List

List input=new ArrayList（）；
add（newarraylist（））；
input.get（0）.add（新整数（1））；
input.get（0）.add（新整数（2））；
组合（输入）；

这实际上并没有回答问题。因为他问他如何才能使它工作，这使它工作，它就工作了？！OP想用

列表调用
组合
，而不是
列表
，我看不出有什么区别。他必须编辑函数或函数调用，因为他没有指定哪一个是固定的，我得到了一个解决方案。但是问题已经解决了，所以讨论是不相关的：-D（编辑）好的，他在问题中指定了方法不是固定的：-/这实际上并没有回答问题。因为他问他如何使它工作，这使它工作，它工作了？！OP想用
列表调用
组合
，而不是
列表
，我看不出有什么区别。他必须编辑函数或函数调用，因为他没有指定哪一个是固定的，我得到了一个解决方案。但是问题已经解决了，所以讨论是不相关的：-D（编辑）好的，他在问题中指出方法是不固定的：-/