Java 使用泛型和参数化列表的问题

我创建了以下测试类：

public class GenericTest {

    public static class A implements Serializable {

    }

    public static class B implements Serializable {

    }

    public static void main(String[] args) {
        // Error: Type mismatch: cannot convert from List<capture#1-of ? extends Serializable> to List<GenericTest.A>
        //List<A> aList = getInfo().get("A");
        //List<B> BList = getInfo().get("B");

        // Warning: Type safety: Unchecked cast from List<capture#1-of ? extends Serializable> to List<GenericTest.A>
        List<A> aList = (List<A>)getInfo().get("A");
        List<B> BList = (List<B>)getInfo().get("B");
    }

    public static Map<String, List<? extends Serializable>> getInfo() {
        Map<String, List<? extends Serializable>> infoMap = new HashMap<String, List<? extends Serializable>>();

        List<A> aList = new ArrayList<A>();
        List<B> bList = new ArrayList<B>();

        try {
            aList.add(new A());
            infoMap.put("A", aList);

            bList.add(new B());
            infoMap.put("B", bList);
        }
        catch(Exception e) {
            e.printStackTrace();
        }

        return infoMap;
    }    
}

公共类泛型测试{
公共静态类A实现了可序列化{
}
公共静态类B实现了可序列化{
}
公共静态void main（字符串[]args）{
//错误：类型不匹配：无法从列表转换为列表
//List aList=getInfo（）.get（“A”）；
//List BList=getInfo（）.get（“B”）；
//警告：类型安全：未选中从列表到列表的强制转换
List aList=（List）getInfo（）.get（“A”）；
List BList=（List）getInfo（）.get（“B”）；
}
公共静态映射不，没有办法帮助这种情况。您有一个具有两种值的映射（这称为异构映射）类型系统无法表达这一点。您必须在没有类型安全性的情况下进行向下转换。或者这样做，或者完全重新设计以将这两种对象保留在两个单独的结构中。
不，没有办法帮助解决此问题。您有一个具有两种值的单一映射（这称为异构映射）类型系统无法表达这一点。您必须在没有类型安全性的情况下进行向下转换。否则，或者完全重新设计以将这两种对象保留在两个单独的结构中。
您可以尝试这样做。您仍然需要在getList方法中抑制警告，但如果您仅使用addToMap方法添加列表，编译器可以正确地执行此操作检查添加的列表是否与第一个参数中使用的类类型相同。也可以通过谷歌搜索超级类型标记

public static void main(String[] args) {
    List<A> aList = new ArrayList<A>();
    aList.add(new A());
    List<B> bList = new ArrayList<B>();
    bList.add(new B());
    addToMap(A.class,aList);
    addToMap(B.class,bList);        

    List<A> aListFromMap = getList(A.class);
    List<B> bListFromMap = getList(B.class);
}



private static Map<Class<?>,Object> infoMap = new HashMap<Class<?>,Object>();



public static <T extends Serializable> void addToMap(Class<T> key, List<T> value) {
    infoMap.put(key,value);
}


public static <T extends Serializable> List<T> getList(Class<T> key) {
    return (List<T>)(infoMap.get(key));
} 

publicstaticvoidmain（字符串[]args）{
列表列表=新的ArrayList（）；
aList.add（新的A（））；
List bList=new ArrayList（）；
bList.add（新的B（））；
addToMap（A.class，aList）；
addToMap（B.class，bList）；
List aListFromMap=getList（A.class）；
List bListFromMap=getList（B.class）；
}
私有静态映射，对象>（）；
公共静态void addToMap（类键，列表值）{
infoMap.put（键、值）；
}
公共静态列表getList（类键）{
return（List）（infoMap.get（key））；
} 
您可以尝试这样做。您仍然需要抑制getList方法中的警告，但如果您仅使用addToMap方法添加列表，编译器可以正确检查添加的列表是否与第一个参数中使用的类类型相同。也可以通过谷歌搜索超级类型标记

public static void main(String[] args) {
    List<A> aList = new ArrayList<A>();
    aList.add(new A());
    List<B> bList = new ArrayList<B>();
    bList.add(new B());
    addToMap(A.class,aList);
    addToMap(B.class,bList);        

    List<A> aListFromMap = getList(A.class);
    List<B> bListFromMap = getList(B.class);
}



private static Map<Class<?>,Object> infoMap = new HashMap<Class<?>,Object>();



public static <T extends Serializable> void addToMap(Class<T> key, List<T> value) {
    infoMap.put(key,value);
}


public static <T extends Serializable> List<T> getList(Class<T> key) {
    return (List<T>)(infoMap.get(key));
} 

publicstaticvoidmain（字符串[]args）{
列表列表=新的ArrayList（）；
aList.add（新的A（））；
List bList=new ArrayList（）；
bList.add（新的B（））；
addToMap（A.class，aList）；
addToMap（B.class，bList）；
List aListFromMap=getList（A.class）；
List bListFromMap=getList（B.class）；
}
私有静态映射，对象>（）；
公共静态void addToMap（类键，列表值）{
infoMap.put（键、值）；
}
公共静态列表getList（类键）{
return（List）（infoMap.get（key））；
} 
您不应该在方法的返回类型中使用通配符
？
。这意味着您的方法返回未知的内容。您不应该在方法的返回类型中使用通配符
？
。这意味着您的方法返回未知的内容。无论如何，如果您只想使用泛型类型“Serializable”如果您只想使用泛型类型“Serializable”并取消警告，您可以将类型列表更改为：list。无论如何，如果您只想使用泛型类型“Serializable”并取消警告，您可以将类型列表更改为：list