Consumer mapped Class in HashMap

This is essentially just like the type-safe heterogeneous container described by Joshua Bloch, except you can’t use the Class to cast the result.

Weirdly, I can’t find a great example existing on SO, so here is one:

package mcve;
import java.util.*;
import java.util.function.*;

class ClassToConsumerMap {
    private final Map<Class<?>, Consumer<?>> map =
        new HashMap<>();

    @SuppressWarnings("unchecked")
    public <T> Consumer<? super T> put(Class<T> key, Consumer<? super T> c) {
        return (Consumer<? super T>) map.put(key, c);
    }

    @SuppressWarnings("unchecked")
    public <T> Consumer<? super T> get(Class<T> key) {
        return (Consumer<? super T>) map.get(key);
    }
}

That’s type-safe, because the relation between keys and values is enforced by the signature of the put method.

One annoying thing about the limitations of Java’s generics is that one of these containers can’t be written for a generic value type, because there’s no way to do e.g.:

class ClassToGenericValueMap<V> {
    ...
    public <T> V<T> put(Class<T> key, V<T> val) {...}
    public <T> V<T> get(Class<T> key) {...}
}

Other notes:

• I would use a regular HashMap or a LinkedHashMap for this. HashMap is better maintained and has many optimizations that IdentityHashMap doesn’t have.

• If it’s necessary to use generic types, like Consumer<List<String>>, then you need to use something like Guava TypeToken as the key, because Class can only represent the erasure of a type.

• Guava has a ClassToInstanceMap for when you need a Map<Class<T>, T>.

Sometimes people want to do something like this, with a class-to-consumer map:

public <T> void accept(T obj) {
   Consumer<? super T> c = get(obj.getClass());
   if (c != null)
       c.accept(obj);
}

That is, given any object, find the consumer in the map bound to that object’s class and pass the object to the consumer’s accept method.

That example won’t compile, though, because getClass() is actually specified to return a Class<? extends |T|>, where |T| means the erasure of T. (See JLS §4.3.2.) In the above example, the erasure of T is Object, so obj.getClass() returns a plain Class<?>.

This issue can be solved with a capturing helper method:

public void accept(Object obj) {
    accept(obj.getClass(), obj);
}
private <T> void accept(Class<T> key, Object obj) {
    Consumer<? super T> c = get(key);
    if (c != null)
        c.accept(key.cast(obj));
}

Also, if you want a modified version of get which returns any applicable consumer, you could use something like this:

public <T> Consumer<? super T> findApplicable(Class<T> key) {
    Consumer<? super T> c = get(key);
    if (c == null) {
        for (Map.Entry<Class<?>, Consumer<?>> e : map.entrySet()) {
            if (e.getKey().isAssignableFrom(key)) {
                @SuppressWarnings("unchecked")
                Consumer<? super T> value =
                    (Consumer<? super T>) e.getValue();
                c = value;
                break;
            }
        }
    }
    return c;
}

That lets us put general supertype consumers in the map, like this:

ctcm.put(Object.class, System.out::println);

And then retrieve with a subtype class:

Consumer<? super String> c = ctcm.findApplicable(String.class);
c.accept("hello world");

---

Here’s a slightly more general example, this time using UnaryOperator and no bounded wildcards:

package mcve;
import java.util.*;
import java.util.function.*;

public class ClassToUnaryOpMap {
    private final Map<Class<?>, UnaryOperator<?>> map =
        new HashMap<>();

    @SuppressWarnings("unchecked")
    public <T> UnaryOperator<T> put(Class<T> key, UnaryOperator<T> op) {
        return (UnaryOperator<T>) map.put(key, op);
    }

    @SuppressWarnings("unchecked")
    public <T> UnaryOperator<T> get(Class<T> key) {
        return (UnaryOperator<T>) map.get(key);
    }
}

The ? super bounded wildcard in the first example is specific to consumers, and I thought an example without wildcards might be easier to read.