Jak używać generycznych w mapie Komparatora, aby uniknąć ostrzeżeń

Question

Chcę utworzyć mapę komparatorów w następujący sposób, ta mapa będzie używana do zapewnienia komparatora dla każdego rodzaju klasy.

Jak mogę zamienić rodzajowy? w deklaracji mojej mapy, aby mieć pewność, że zawsze mam ten sam typ Klasy w kluczu i wartości mojej mapy (komparatory)?

Chcę również, aby zmniejszyć liczbę ostrzeżeń

private static final Map<Class<?>, Comparator<?>> comparators = new HashMap<>(); 

static { 
    comparators.put(Identifiable.class, new Comparator<Identifiable>() { 
     @Override 
     public int compare(Identifiable o1, Identifiable o2) { 
      return o1.getId().compareTo(o2.getId()); 
     } 
    }); 
    comparators.put(MyClass.class, new Comparator<MyClass>() { 
     @Override 
     public int compare(EIntersection o1, EIntersection o2) { 
      return o1.getRef().compareTo(o2.getRef()); 
     } 
    }); 
    ... 
} 

Answer 1

Aby zmniejszyć ilość ostrzeżeń można umieścić owijkę wokół mapie porównawczym (like in this answer).

Dzięki temu rozwiązaniu musisz rzucić ten typ tylko raz w swojej klasie otoki (i otrzymać tylko jedno ostrzeżenie). Podczas dzwonienia otrzymasz klasę otoki, nie otrzymasz ostrzeżenia i nie będziesz musiał rzucać wartości.

Przykład:

private static final Map<Class<?>, Comparator<?>> oldComparatorsMap = new HashMap<>(); 
private static final Map<Class<?>, Comparator<?>> newComparatorsMap = new MyTypeSafeMap(); 

static { 
    oldComparatorsMap.put(String.class, new Comparator<String>() { 
     @Override 
     public int compare(String o1, String o2) { 
      return o1.compareTo(o2); 
     } 
    }); 
    oldComparatorsMap.put(Integer.class, new Comparator<Integer>() { 
     @Override 
     public int compare(Integer o1, Integer o2) { 
      return o1.compareTo(o2); 
     } 
    }); 
    newComparatorsMap.put(String.class, new Comparator<String>() { 
     @Override 
     public int compare(String o1, String o2) { 
      return o1.compareTo(o2); 
     } 
    }); 
    newComparatorsMap.put(Integer.class, new Comparator<Integer>() { 
     @Override 
     public int compare(Integer o1, Integer o2) { 
      return o1.compareTo(o2); 
     } 
    }); 
} 

public static void main(String[] args) { 

    Comparator<String> c1 = (Comparator<String>)oldComparatorsMap.get(String.class); // Warning for every call on get with a cast 

    Comparator<String> c2 = newComparatorsMap.get(String.class); // No warning here and no cast 

} 

static class MyTypeSafeMap { 
    private static final Map<Class<?>, Comparator<?>> innerComparatorsMap = new HashMap<>(); 

    public <T> void put(Class<T> key, Comparator<T> value) { 
    innerComparatorsMap .put(key, value); 
    } 

    public <T> Comparator<T> get(Class<T> key) { 
    return (Comparator<T>) innerComparatorsMap .get(key); // Only one warning here 
    // we know it's safe, but the compiler can't prove it 
    } 
}