Génériques Java: compareTo et "capture # 1-of?"

La suite me donne un message d'erreur:

public static List<Comparable<?>> merge(Set<List<Comparable<?>>> lists) {
    List<Comparable<?>> result = new LinkedList<Comparable<?>>();
    HashBiMap<List<Comparable<?>>, Integer> location = HashBiMap.create();

    int totalSize;
    for (List<Comparable<?>> l : lists) {
        location.put(l, 0);
        totalSize += l.size();
    }

    boolean first;
    List<Comparable<?>> lowest; //the list with the lowest item to add
    int index;

    while (result.size() < totalSize) {
        first = true;

        for (List<Comparable<?>> l : lists) {
            if (! l.isEmpty()) {
                if (first) {
                    lowest = l;
                }
                else if (l.get(location.get(l)).compareTo(lowest.get(location.get(lowest))) <= 0) { //error here
                    lowest = l;
                }
            }
        }
        index = location.get(lowest);
        result.add(lowest.get(index));
        lowest.remove(index);
    }
    return result;
}

L'erreur est:

The method compareTo(capture#1-of ?) in the type Comparable<capture#1-of ?> is not applicable for the arguments (Comparable<capture#2-of ?>)

Ce qui se passe ici? J'ai fait le type de tout Comparable si je pouvais l'appeler .compareTo et trier cette liste. Suis-je utiliser les génériques de façon incorrecte?

source d'informationauteur Nick Heiner

  1. 20

    List<?> signifie "Liste de tout", de sorte que deux objets de ce type ne sont pas les mêmes: On peut être une liste de Stringl'autre une liste de BigDecimal. Évidemment, ce ne sont pas les mêmes.

    List<T> signifie "Liste de rien, mais quand vous voyez T encore une fois, c'est la même T".

    Vous devez indiquer au compilateur si vous parlez du même type dans des endroits différents. Essayez:

    public static <T extends Comparable<? super T>> List<T> merge(Set<List<T>> lists) {
    List<T> result = new LinkedList<T>();
    HashBiMap<List<T>, Integer> location = HashBiMap.create();

    [EDIT] Donc, ce n'est <T extends Comparable<? super T>> List<T> veux dire? La première partie définit un type T avec les propriétés suivantes: Il doit implémenter l'interface Comparable<? super T> (ou Comparable<X> où X est également défini en termes de T).

    ? super T signifie que le type qui l' Comparable supports doivent T ou l'un de ses super-types.

    Imaginez un instant cet héritage: Double extends Integer extends Number. Ce n'est pas correct en Java, mais imaginez que Double est juste un Integer en plus d'une fraction de la partie. Dans ce scénario, un Comparable qui fonctionne pour Number fonctionne également pour les Integer et Double depuis proviennent tous deux Number. Donc Comparable<Number> satisfaire les super partie pour T être NumberInteger ou Double.

    Aussi longtemps que chacun de ces types de support de la Comparable interface, qu'ils respectent également la première partie de la déclaration. Cela signifie, vous pouvez passer dans Number pour T et le code résultant peut également il y a Integer et Double cas dans les listes. Si vous Integer pour Tvous pouvez toujours utiliser Double mais Number n'est pas possible car il n'est pas satisfait T extends Comparable plus (le super partie va continuer à travailler, tout de même).

    La prochaine étape est de comprendre que l'expression entre static et List déclare simplement les propriétés du type T qui est utilisé plus tard dans le code. De cette façon, vous n'avez pas à répéter cette longue déclaration, encore et encore. C'est le comportement de la méthode (comme public) et ne fait pas partie du code.