类型 T 不是通用的；它不能在泛型函数中使用参数 <?> 错误进行参数化

Question

我想创建一个通用函数，它接受任何 Map 和一个 String 键，如果键不存在于映射中，那么它应该创建一个值类型的新实例（它被传递）并将它放在映射然后返回它。

这是我的实现

public <T> T getValueFromMap(Map<String, T> map, String key, Class<T> valueClass){
    T value = map.get(key);
    if (value == null){
        try {
            value = valueClass.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        map.put(key, value);
    }
    return value;
}

如果我将它与普通（非通用）列表一起用作值类型，它就可以工作，

Map<String,List> myMap;
List value = getValueFromMap(myMap, "aKey", List.class) //works

但不适用于泛型类型列表

Map<String,List<String>> myMap;
List<String> value = getValueFromMap(myMap, "aKey", List.class) //does not work

此外，如果我尝试通过将 Map<String, T> 映射参数更改为 Map<String, T<?>> 来使其具有通用性，它会抱怨 the type T is not generic; it cannot be parameterized with arguments <?>

泛型参数本身可以泛型吗？

有没有办法创建满足上述要求的函数？

~更新

感谢大家的所有有见地的回答。

我已验证接受的解决方案适用于使用此代码的任何值类型

    Map<String, Map<String, List<String>>> outer = 
            new HashMap<String, Map<String,List<String>>>();

    Map<String, List<String>> inner = getValueFromMap(outer, "b", 
            (Class<Map<String, List<String>>>)(Class<?>)HashMap.class);

    List<String> list = getValueFromMap(inner, "a", 
            (Class<List<String>>)(Class<?>)ArrayList.class);

Answer 1

在您的情况下，您需要最具体的类型，即 String。 List.class 返回您Class<List<?>> 在您的情况下您需要特定类型，因此您需要添加演员Class<List<String>>

 Map<String,List<String>> myMap = new HashMap<String, List<String>>();;
 List<String> value = getValueFromMap(myMap, "aKey",
           (Class<List<String>>)(Class<?>)ArrayList.class) ;

现在如果你调用如下方法

 getValueFromMap(myMap, "aKey",      List.class) 
                ^^^T is List<String>  ^^^ T is List<?> wild char since List.class
                                          will return you Class<List<?>>

所以你对T 的定义导致编译器混淆，所以你得到编译错误。

你不能创建List.class的实例，因为它是接口，你需要它的实现类，所以用ArrayList.class调用方法

Answer 2

由于泛型类型信息在运行时会被删除，因此您不能使用本身为泛型的参数调用泛型方法。

见http://www.angelikalanger.com/GenericsFAQ/FAQSections/ProgrammingIdioms.html#FAQ004

如果您总是使用列表映射，那么您可以声明采用Map<String, List<T>>的方法

Answer 3

这里的问题是您要求Class<T> 参数，而实际上无法（直接）获得Class<List<String>> 对象。

List.class 为您提供 Class<List>，但 List<String>.class 甚至无法编译（语法不正确）。

解决方法是自己将类对象转换为通用版本。您需要先向上转换，否则 Java 会抱怨类型不可分配：

Class<List<String>> clz = (Class<List<String>>)(Class<?>)List.class;

由于泛型是通过擦除实现的，因此强制转换从根本上不会做任何事情 - 但它让编译器对T 的推断感到满意，并允许像您这样灵活的泛型方法工作。当您想要传入 Class<T> 令牌时，需要使用这种解决方法并不少见。

Answer 4

第一个示例适用于您使用不推荐的原始类型。

为了解决你的编译错误，你可能不希望将类限制为 T，而是允许一些超 T

public <T> T getValueFromMap(Map<String, T> map, String key, Class<? super T> valueClass)

但是您将没有保存转换，您需要将新实例的结果转换为 (T)。而且你不能使用 List 作为类，因为它是一个 iterface，你不能创建它的实例。

public <K,V> V getValueFromMap(Map<K, V> map, K key, Class<? super V> valueClass){

    if(map.containsKey(key) == false) {
        try {
            map.put(key, (V) valueClass.newInstance());
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    return map.get(key);
}

---

Map<String,ArrayList<String>> myMap = new HashMap<String, ArrayList<String>>();
List<String> value = getValueFromMap(myMap, "aKey", ArrayList.class); //will work

编辑

但是 OP 期望的基本形式 Map<String,List<String> myMap 呢？

我们应该知道ArrayList 是List 的超类型，但ArrayList<String> 不是List<String> 的超类型，但它是可赋值的。

那么让我们试试吧：

示例1：getValueFromMap(myMap, "aKey", ArrayList.class); //Compilation error

示例 2：getValueFromMap(myMap, "aKey", List.class); //Runtime error

解决方案可能是假设如果类是 List 则创建 ArrayList。

这迫使我们创建一些不合适的代码。

public static <V> V createInstace(Class<V> valueClass) throws InstantiationException, IllegalAccessException {

        if(List.class.isAssignableFrom(valueClass)) {
            return (V) new ArrayList<V>();
        }

        return valueClass.newInstance();

    }

此代码与泛型没有任何共同之处，但可以正常工作。

最后我们以

结束

public static void main(String[] args) {

        Map<String,List<String>> myMap = new HashMap<String, List<String>>();
        List<String> value = getValueFromMap(myMap, "aKey", List.class); //does not work

        value.add("Success");

        System.out.println(value);
    }


    public static <K,V> V getValueFromMap(Map<K, V> map, K key, Class<? super V> valueClass){

        if(map.containsKey(key) == false) {
            try {
                map.put(key, (V) createInstace(valueClass));
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

        return map.get(key);
    }

    public static <V> V createInstace(Class<V> valueClass) throws InstantiationException, IllegalAccessException {

        if(List.class.isAssignableFrom(valueClass)) {
            return (V) new ArrayList<V>();
        }

        return valueClass.newInstance();

    }

如果这是[Sucess]，则结果。