Java – types are created safely to be passed to comparator Function instance of comparing()

Suppose I have a method with the following signature:

<T,U extends Comparable<? super U>> Comparator<T> method(Map<String,Function<? super T,? extends U>> comparatorFunctionMap)

This method takes a function map (using string keys) and creates a comparator < T > Results (how important) The mapping value is function & lt;? Instance super T,? Extend U > so that they can be passed directly to comparator comparing().

How do I populate this map in a type safe manner? Suppose I have a person with an attribute name and age (and their getters)

When I do the following:

Map<String,Function<? super Person,? extends Comparable>> map1 = new HashMap<>();
map1.put("name",Person::getName);
method(map1);

I received warnings on lines 1 and 3 If I try to do this, for example:

Map<String,? extends Comparable<?>>> map2 = new HashMap<>();
map2.put("name",Person::getName);
method(map2);

The third line is a compilation error

Is there any way to do this type safely?

Solution

If you want to add person:: getname and person:: getage to the map, you will not be able to use the method you proposed to sign, because no u is string, integer and comparable

Basically, your map is map < string, function < T, comparable > Because comparable objects are independent of each other in terms of type

I don't think you can bypass it without using the primitive type, which may be as follows Note that you still have type security (you must pass comparable to the map)

static void m() {
  Map<String,Function<Person,Comparable<?>>> map = new HashMap<>();
  map.put("name",Person::getName);
  map.put("age",Person::getAge);
  Comparator<Person> c = method(map);
}


@SuppressWarnings(value = {"unchecked","rawtypes"})
static <T> Comparator<T> method(String name,Map<String,Function<T,Comparable<?>>> comparatorFunctionMap) {
  Function f = (Function) comparatorFunctionMap.get("age");
  Comparator<T> c = Comparator.comparing(f);
  return c;
}

The only (I think) limitation is that technically, weird can implement comparable < string > through a strange class, which may lead to runtime errors