Avoir une erreur lors de l'utilisation en chaîne Comparator

ball_jan:

Je suis en train de créer une classe implémentant comparable. Lorsque tous les éléments de classe sont des nombres entiers, tout fonctionne bien. Quand je vais avec une ficelle et d' utiliser comparingplutôt que comparingInt, je reçois les erreurs suivantes.

• nombre incorrect d'arguments de type générique pour la méthode de comparaison (Function) de type comparateur; il ne peut pas être paramétrés avec des arguments

• Le type myClassdoes définissent pas GetFrom (T) qui est applicable ici

public class myClass implements Comparable<myClass> {
    @Column (name="From")
    private String from;
    @Column (name="To")
    private String to;
    @Column (name="With")
    private String with;
    @Column (name="amount")
    private int amount;

    // Setters, getters, constructor

    Comparator<myClass > comp = Comparator.<myClass>comparing(myClass::getFrom)
            .thenComparing(myClass::getTo)
            .thenComparing(myClass::getWith)
            .thenComparingInt(myClass::getAmount);
    @Override
    public int compareTo(myClass o) {
        return comp.compare(this, o);
    }
}

Quelqu'un pourrait-il indiquer ce que je pourrais être absent ici?

Michalk:

Comparator :: on compare est une méthode générique qui prend une fonction qui est utilisée pour extraire la valeur à comparer. Vous avez passé une référence de méthode pour la myClass::getFromméthode qui retourne un Stringet sera appelé sur myClassobjet de type (par Function::apply). C'est pourquoi vous devez passer des types génériques myClasset String.

Cependant , vous pouvez ommettre ces types génériques parce que vous assignez votre comparateur de Comparator<myClass> compvariable afin types peuvent être automatiquement insérées (également en utilisant des types de votre référence de méthode).

Vous cherchez le regard de plus déposons sur la Comparator::comparing(Function)mise en œuvre de la méthode:

static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> var0) {
    Objects.requireNonNull(var0);
    return (Comparator)((Serializable)((var1x, var2x) -> {
        return ((Comparable)var0.apply(var1x)).compareTo(var0.apply(var2x));
    }));
}

Ici Tsera myClasset Usera String. Fonction var0prendra myClasscomme paramètre et retourne String(si la méthode de référence à myClass::getFromvolonté travail ici - en général ce sera comme l' invocation getFromsur l' myClassobjet). En fait , comme vous pouvez voir cette méthode renvoie une Comparatoren fonction lambda qui utilisera la fonction var0des valeurs d'extrait de var1xet var2x( les deux d'entre eux seront myClasstypes). Pour moi , il ressemble un peu à une fermeture.