Inline comparateur vs personnalisé comparateur en Java

Lors du tri d'une liste, il n'existe aucune différence de performance entre l'utilisation de java Comparateur en ligne (avec un anonyme intérieur de la classe) vs la mise en œuvre d'un personnel distinct de Comparaison de la classe?

1.

public class SortByErrorComparator implements Comparator<WorkflowError> {
    public int compare(WorkflowError obj1, WorkflowError obj2) {
        return obj1.getErrorCode().compareTo(obj2.getErrorCode());
    }
}
Collections.sort(list, new SortByErrorComparator()) ;

2.

Collections.sort(list, new Comparator<WorkflowError>() {
    public int compare(WorkflowError obj1, WorkflowError obj2) {
        return obj1.getErrorCode().compareTo(obj2.getErrorCode());
    }
});

Aussi, quand le compare() méthode-elle être invoquée?

Vous pourriez vouloir vérifier cette réponse: stackoverflow.com/a/5468644/423991
Depuis le travail qui est fait par la même méthode: pourquoi devrait-il y avoir une différence? Et l'invocation dépend de l'algorithme de tri - chaque fois que deux éléments dans la collection doivent être comparés. Et, alors, dans une certaine mesure, de la première commande de données.
"lorsque cette méthode sera invoquée" - vous pouvez lire à propos de la comparaison de tri.

OriginalL'auteur 1355 | 2015-06-23

  1. 12

    Il y a aussi l'option 3 - un lambda Function:

    Collections.sort(list, (a, b) -> a.getErrorCode().compareTo(b.getErrorCode()));

    qui devrait être d'environ 2 x plus vite, selon cette base de données de référence.

    ... ou (grâce à @JB Nizet) option 4:

    list.sort(Comparator.comparing(WorkflowError::getErrorCode))
    Si vous êtes à l'aide de lambda, alors vous êtes sur Java 8. Et si vous êtes sur Java 8, vous pouvez simplement utiliser list.sort(Comparator.comparing(WorkflowError::getErrorCode)
    Pourquoi lambda devrait être plus rapide? Le post que vous avez lié dit il n'y a pas de différence de performances entre la classe anonyme et lambda.

    OriginalL'auteur Bohemian

  2. 3

    Il ne devrait pas y avoir de différence de performances entre les deux variantes, depuis anonyme classes doivent produire à l'identique de l'octet code des classes régulières (en supposant qu'ils ont le même code source). La seule différence est que ils ont un nom généré.

    La compare méthode sera invoquée par Collections.sort chaque fois qu'il doit comparer deux éléments de la Liste à trier.

    Pour un réponse sans "ne devrait pas" et "devrait", vous pourriez avoir produit un octet d'analyse de code ;-))
    C'est un bon point. Je m'excuse de ne pas avoir le temps pour ça maintenant.

    OriginalL'auteur Eran

  3. 3

    J'ai fait un petit test et n'a trouvé aucune différence (juste quelques petites exécuter la ligne de comparaison montre une légèrement meilleure performance). C'est le code utilisé pour faire le test:

    public class ComparatorTest {
private static final int MAX = 1000000;
private static final int RUN = 10000;
public static void main(String[] args) {
List<A> list = new ArrayList<A>();
long externalComparatorClassTotalTime = 0;
long inlineCompartorTotalTime = 0;
for (int i = RUN; i > 0; i--) {
init(list);
externalComparatorClassTotalTime += externalComparatorClassTest(list);
init(list);
inlineCompartorTotalTime += inlineCompartorTest(list);
}
System.out.format("List with %d elements and %d runs%n", MAX, RUN);
System.out.println("external Comparator class average millis: " + externalComparatorClassTotalTime / RUN);
System.out.println("inline Comparator class average millis: " + inlineCompartorTotalTime / RUN);
}
private static void init(List<A> list) {
list.clear();
for (int i = MAX; i > 0; i--) {
list.add(new A(i));
}
}
private static long inlineCompartorTest(List<A> secondList) {
long start = System.currentTimeMillis();
Collections.sort(secondList, new Comparator<A>() {
public int compare(A obj1, A obj2) {
return obj1.getVal().compareTo(obj2.getVal());
}
});
return System.currentTimeMillis() - start;
}
private static long externalComparatorClassTest(List<A> firstList) {
long start = System.currentTimeMillis();
Collections.sort(firstList, new MyComparatorOne());
return System.currentTimeMillis() - start;
}
}

    Comparateur de classe:

    public class MyComparatorOne implements Comparator<A> {
public int compare(A obj1, A obj2) {
return obj1.getVal().compareTo(obj2.getVal());
}
}

    et la sortie est: 

    List with 1000000 elements and 10000 runs
external Comparator class average millis: 3
inline Comparator class average millis: 3

    Si vous avez plusieurs invocation au comparateur de garder une instance de il serait utile

    OriginalL'auteur Paizo