Java按泛型类型获取集合

Question

Let's say I have my class Context like this.

public class Context {
    Set<A> sA;
    Set<B> sB;
    Set<C> sC;
}

Then I have a generic class Performer , that wants to perform operations based on the generic type from the Context class, in the following way - not possible in Java.

public class Performer<T> { // T can be type of A,B or C

   public void saveToSet(T t) {
       Context.Set<T>.add(t); 
   }
}

Then, if I say something like saveToSet(B b) , the right set from the Context will be called, in this case sB (Set<B>) and the new instance will be added to that set.

Ok, the question... How do to this in Java? :D

Answer 1

Sadly such an approach will not work in Java due to type erasure .

Essentially all the runtime will see is Context.Set<java.lang.Object>.add(t); and the collapse of your fields to Set s of java.lang.Object s, and so it will be unable to disambiguate.

You could work around this by writing overloads like saveToSet(A a) , saveToSet(B b) etc.

In many ways, including this one, Java generics are the poor cousin of C++ templates.

Answer 2

//Not very ice, but something like this can be useful

if (x instanceof A) {
    sA.add((A)x);
    return;
}

if (x instanceof B) {
    sB.add((B)x);
    return;
}

Answer 3

This will not work due to a concept in Java called as type erasure . Basically, the generic type is erased at runtime, and the runtime will not know which type of object it was or is. So no, you cannot do something like that.

You can, however, make separate methods, or you can make a inherited classes and implement specific logic in that overriden method.

Answer 4

One workaround for Java is using enriched types. Those are basically types that hold their own generic parameters as Class<T> attributes. So, instead of using a standard Set , use your own implementation that stores the class. Something like:

class TypeStoringSet<T> extends HashSet<T> {
     private Class<T> clazz;
     ... getter and setter here

     public TypeStoringSet<T>(Class<T> clazz) {
          super();
          this.clazz = clazz;
     }
}

Answer 5

maybe you could use such approach.

class Context {
    Map<String,Set<Object>> datasets = new HashMap<>();

    public <T> void add(T data){
        final String name = data.getClass().getName();
        if(!datasets.containsKey(name)) datasets.put(name, new HashSet<>());
        datasets.get(name).add(data);
    }

    public <T> Set<T> get(Class<T> type){
        return (Set<T>) datasets.get(type.getName());
    }
}

class Performer<T> { // T can be ANY type

    public void saveToSet(T t) {
        final Context context = new Context();
        context.add(t);
    }
}

    final Set<A> aSet = context.get(A.class);
    final Set<B> bSet = context.get(B.class);
    final Set<C> cSet = context.get(C.class);

other possible way to nail it is named injection and method interception with Guice (minus: low performance) and there are lots of optimizations needed to be done to this code ( class type handling, may be MapMultibinding from Guice to inject datasets )

Answer 6

Actually you can achieve your goal and bypass type erasure using reflection. But only if your Context has fields with explicitly defined generic type parameters.

So if you are not afraid of performance penalty then reflection is your friend. You can reflect type parameter of each Set field like this:

// you can fill that lookup map upon Producer creation
Map<Type, Field> lookup = new HashMap<>();
for (Field field : Context.class.getDeclaredFields()) {
    // this code relies on fact that Set has only one
    // type argument which is not parametrized
    // also you need of course do some sanity checks
    // (i.e field is a type of Set, etc)

    Type setType = field.getGenericType();
    Type setGenericArgument =
       ((ParameterizedType) superClass).getActualTypeArguments()[0];

    field.setAccisseble(true);
    lookup.put(setGenericArgument, field);
}

After that you can use obtained type info to implement your saveToSet method

public void saveToSet(T t) {
    // also do exception processing and lookup 
    // map checks here
    Field field = lookup.get(t.getClass());
    ((Set<T>) field.get(context)).add(t); 
}