Java 嵌套逆变类型中的类型不匹配

给定该类（其一部分）

import java.util.*；
导入java.util.stream.collector；
公共A类{
私有映射映射=新建LinkedHashMap（）；
公共地图getMap（）{
返回集合。不可修改映射（map）；
}
公共静态地图排序（Map-Map，Comparator泛型是不变的。如果您声明一个参数
Comparator
，那么它需要的正是
Comparator
。在这种情况下，通过使
K=String
和
V=Collection
的映射，您有
K
和
V
。这将使第二个参数
ComparatorMmhm>，我现在有点明白问题了。我确实同意
K
和
V
的推断类型（这正是我想要的），但我不理解这里的差异位。看起来
Comparator
真的不是
ComparatorWell，
Map的子类型。Entry
当然是
Map的子类型。Entry@DavidWallace，谢谢！现在我明白了。我将坚持使用
Map-sorted（Map-Map，Comparator）
import java.util.*;
import java.util.stream.Collectors;

public class A {
    private Map<String, Set<String>> map = new LinkedHashMap<>();

    public Map<String, Collection<String>> getMap() {
        return Collections.unmodifiableMap(map);
    }

    public static <K, V> Map<K, V> sorted(Map<K, V> map, Comparator<Map.Entry<? super K, ? super V>> comparator) {
        return map
                .entrySet()
                .stream()
                .sorted(comparator)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

    public Map<String, Collection<String>> getSortedMap() {
        Comparator<Map.Entry<String, Collection<String>>> cmp =
                Map.Entry.comparingByValue(Comparator.comparingInt(Collection::size));
        return sorted(getMap(), cmp);
    }
}

error: method sorted in class A cannot be applied to given types;
    return sorted(getMap(), cmp);
            ^
            required: Map<K,V>,Comparator<Entry<? super K,? super V>>
        found: Map<String,Collection<String>>,Comparator<Entry<String,Collection<String>>>
        reason: cannot infer type-variable(s) K,V
        (argument mismatch; Comparator<Entry<String,Collection<String>>> cannot be converted to Comparator<Entry<? super K,? super V>>)
        where K,V are type-variables:
        K extends Object declared in method <K,V>sorted(Map<K,V>,Comparator<Entry<? super K,? super V>>)
        V extends Object declared in method <K,V>sorted(Map<K,V>,Comparator<Entry<? super K,? super V>>)
        1 error

public static <K, V> Map<K, V> sorted(Map<K, V> map,
        Comparator<? super Map.Entry<K, V>> comparator) {
    ...
}