Why Java needs an argument for a method to correctly deduce generics?

Question

Suppose we have the following code:

public class Main {
    public static void main(String[] args) {

    }

    private static <K, V extends Comparable<V>> Map<K, V> sorted(Map<K, V> map) {
        return map.entrySet()
                .stream()
                .sorted(Comparator.comparing(Entry::getValue))
                .collect(Collectors.toMap(Entry::getKey, Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
    }
}

A fairly simple snippet - we take a map and return another map that represents the same map, but sorted according to its values.

Let's change the functionality a little bit - instead of returning something based on an argument, let's introduce and work on a static object:

public class Main {
    public static void main(String[] args) {

    }

    private static Map<Integer, String> map = new HashMap<>();

    private static <K, V extends Comparable<V>> Map<K, V> sorted() {
        return map.entrySet()
                .stream()
                .sorted(Comparator.comparing(Entry::getValue))
                .collect(Collectors.toMap(Entry::getKey, Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
    }
}

Note that the only thing we changed was getting rid of the argument and, instead, working with a static field. One may wonder why then introduce the generics K and V at all - after all they will always be Integer and String, respectively. But wouldn't that mean that Java can easily deduce those arguments? Why exactly does it fail with an error of:

Error:(16, 25) java: incompatible types: inference variable K has incompatible bounds
equality constraints: K,K
lower bounds: java.lang.Integer

I have seen some questions regarding similar error messages, but I couldn't get any information from there. Why exactly does this fail? It's maybe worth to mention that while the compiler produces the above error, when using IntelliJ IDEA, the Entry::getKey and Entry::getValue method references are highlighed in red and, when hovered over, the following message gets displayed:

Non-static method cannot be referenced from a static context.

Which is weird, since I see nothing alike in the actual error message from javac.

Answer 1

The concrete type arguments are determined at the call site.

For example, any of these are legal calls:

Map<Void, Integer> mapA = Main.sorted();
Map<String, String> mapB = Main.sorted();
Map<Integer, GregorianCalendar> mapC = Main.sorted();

...but, given the method definition, they would all return the same value; since they are of different types, at least two of mapA..C are type-incorrect (and, in fact, all three are).

The sole point of generics is to allow you to omit explicit casts; this is advantageous, because the compiler is able to reason better than you about whether a cast (or, rather, all the casts throughout the code) are safe.

So, if you write that a method returns a Map<Void, Integer>, or whatever, the compiler is going to do everything it can to make sure that it really does return a Map<Void, Integer>. Or, to put this another way, the compiler ensures that it returns a Map where every element of the keySet() can be safely cast to a Void; and every element of values() can be safely cast to an Integer.

Thus far I have only talked about concrete type parameters: Void, Integer, String, GregorianCalendar. But the compiler doesn't draw distinction between such type parameters and type variables. Thus, if you say that a method returns a Map<K, V>, the compiler is going to do everything it can to make sure that it returns a Map where every element of the keySet() can be cast to K, and every element of the values() can be cast to V.

The important point here is that this has to work for any K and any V, because, as stated in the first line of the question, the concrete values of K and V are determined at the call site.

There are only a small number of Ks that an Integer can be safely cast to (Integer, Number, Object, Serializable); a null Integer can be cast to any other type, but the compiler doesn't know if the Integers are null. So the compiler is simply saying "I can't be sure that these casts would be safe, so I'm going disallow them".

(A similar situation applies to V).

Your method only returns a safe value when K and V are Integer and String respectively, because map is a Map<Integer, String>. As such, you don't need type variables, as the method will always return a Map<Integer, String>.

private static Map<Integer, String> sorted() {
    return map.entrySet()
            .stream()
            .sorted(Comparator.comparing(Entry::getValue))
            .collect(Collectors.toMap(Entry::getKey, Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
}

(or it could be a Map<Object, String>, or whatever. The point is that you don't need type variables).