如何检查地图类型是否扩展了Number

Question

I'm trying to check if a Map<String, T> contains Objects (T) of type Double or Integer.

I don't want to use the actual Objects in the map for checking the class since It's not certain that the Map contains Objects at all.

I can achieve this by doing the following (Assuming the field is containing a Map):

ParameterizedType type = (ParameterizedType) field.getGenericType(); 

isNumeric(type);

/**
 * @param type
 * @return Returns true if type is numeric
 */
private static boolean isNumeric(ParameterizedType type) {
    return  type.getActualTypeArguments()[1].toString().equals("? extends java.lang.Number");
}

It's sufficient for me but it doesn't feel like a clean solution.

However, I can retrieve the Type of the getActualTypeArguments()[1] by doing the following:

Type typeOfSecondGeneric = type.getActualTypeArguments()[1]; // equals '? extends java.lang.Number'

I can't use Number.class.isAssignableFrom(typeOfSecondGeneric); // Class expected Number.class.isAssignableFrom(typeOfSecondGeneric); // Class expected

After I researched a bit, I didn't came up with a better solution than doing the String comparison.

What am I getting wrong?

Help is appreciated!

Answer 1

An ad hoc solution could be something like this:

private static boolean isNumericValue(ParameterizedType t) {
    return isSubclassOf(t.getActualTypeArguments()[1], Number.class);
}

private static boolean isSubclassOf(Type t, Class<?> clazz) {
    if (t instanceof Class<?>)
        return clazz.isAssignableFrom((Class<?>) t);
    if (t instanceof ParameterizedType)
        return isSubclassOf(((ParameterizedType) t).getRawType(), clazz);
    Type[] bounds = null;
    if (t instanceof TypeVariable<?>)
        bounds = ((TypeVariable<?>) t).getBounds();
    if (t instanceof WildcardType)
        bounds = ((WildcardType) t).getUpperBounds();
    if (bounds != null && bounds.length > 0)
        return isSubclassOf(bounds[0], clazz);
    return clazz == Object.class;
}

That short example doesn't handle interface types or generic array types. It's also nowhere near to being complete with respect to the actual rules of subtyping.

If it's true that you really do need something like this, I think the better solution is to use Guava TypeToken :

private static final TypeToken<Map<?, ? extends Number>> T =
    new TypeToken<Map<?, ? extends Number>>() {};

private static boolean isNumericValue(ParameterizedType t) {
    return T.isSupertypeOf(t);
}

That said, I'm not all that convinced that you do need this. This looks like an XY problem and you might do better asking a question about the problem you're trying to solve rather than your attempted solution. This is the kind of code that can turn in to a huge pain in the neck after your program is tied down to using it, especially if it's pervasive.

Answer 2

This information is lost at run-time so in general you won't be able to figure out what T really is.

The exception to this general rule are limited to those case in where the map object class itself has a more specific constraint on that T . For example:

class MyDoubleMap<K> extends Map<K, Double> {
...
}    
...
Map<String, Double> standard = new HashMap<>();
Map<String, Double> doubles = new MyDoubleMap<>();
Map<String, Double> annonDoubles = new HashMap<>() {};

With standard any reflection trick won't be able to recover more than T and that it could be anything that extends Object .

However for the other two cases doubles and annonDoubles the reflection code included in other answer should get to the Double assignation to the T .

With doubles it should be easy to see that that information should be available thru reflection as it is integral part of this declaration of MyDoubleMap . Perhaps annonDoubles is a bit less obvious but in fact with the trailing {} it is effectively declaring an anonymous inner class that extends HashMap<String, Double> and so such an information for T (and also for K ) can be recovered by reflection.