web-dev-qa-db-fra.com

Qu'est-ce qui détermine l'ordre croissant ou décroissant dans la classe de collection Comparateur / Comparable?

Je comprends que nous pouvons trier ou commander les objets, stockés dans Collection selon nos exigences.

Bien que je comprenne profondément, je ne suis pas convaincu par le fait que l'ordre d'arrangement ascendant et descendant est atteint par (a - b) -> ascendant ou (b - a) -> descendant où "a" et "b" sont classe membres que nous avons choisi de comparer.

Exemple:

public int compareTo(Student s) {
     return this.grade - s.grade; //ascending order 
    // return s.grade - this.grade; // descending order
}

Quelle est la logique derrière l'ordre des éléments d'objet? comment "(this.grade - s.grade)" si le positif 1 déplace "this.grade" devant et met "s.grade" ensuite dans l'ordre, pourquoi pas l'inverse? Qui valide le résultat de la comparaison (+1, -1, 0) et les met ensuite respectivement dans l'ordre croissant ou décroissant, existe-t-il une documentation décrivant le fonctionnement interne de cette partie?

public class Student implements Comparable <Student>{
    String name;
    int grade;
    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
    public int compareTo(Student s) {
         return this.grade - s.grade; //ascending order 
        // return s.grade - this.grade; // descending order
    }
    public String toString() {
        return this.name + ", " + this.grade;
    }
}

Veuillez partager, merci beaucoup!

Éditer:

Je reçois les documents Java, ma question est la suivante:

sort these grades (13, 2)

Case ascending -> return this.grade - s.grade;

picture in my mind: 
compare (13, 2) , (13 - 2) > 0 so move 2 to front.
result -> 2, 13
------
Case descending -> return s.grade - this.grade;

picture in my mind: 
compare (2, 13) , (2 - 13) < 0 so move 13 to front.

result -> 13, 2

"Comment cela peut-il arriver?" était ma question initiale. J'ai lu les documents, je n'arrivais toujours pas à comprendre.

javasortingcollectionsinterfacecomparable
19
David Prun

Quelle est la logique derrière l'ordre des éléments d'objet? comment "(this.grade - s.grade)" si le positif 1 déplace "this.grade" devant et met "s.grade" ensuite dans l'ordre, pourquoi pas l'inverse?

Utiliser des nombres négatifs pour dire "c'est moins que cela", des nombres positifs pour dire "c'est plus que ça" et 0 pour dire "ces 2 choses sont égales" est utilisé dans de nombreux langages informatiques depuis plus de 30 ans.

Qui valide le résultat de la comparaison (+1, -1, 0) puis met respectivement en ordre croissant/décroissant, existe-t-il une documentation décrivant le fonctionnement interne de cette partie?

Il existe plusieurs classes internes qui utilisent la valeur de retour pour réorganiser les éléments dans les tableaux ou les collections, notamment

Collections.sort()Arrays.sort()TreeSet

MODIFIER

Pour répondre à COMMENT cela fonctionne, vous devrez regarder le code source de chacune des classes que j'ai énumérées ci-dessus. Certains d'entre eux sont assez compliqués pour essayer de rendre le tri aussi efficace que possible. Mais en général, tout se résume à un code comme celui-ci:

if( data[i].compareTo(data[j]) > 0 ){
   // swap data[i] and  data[j]
}
13
dkatzel

@DavidPrun Bonne question. J'ai essayé d'expliquer cela avec un exemple.

(x, y) -> (2, 5)

Ordre croissant (x.compareTo (y)):

if x.compareTo(y) == 1, then x > y , since y is smaller than x, you would have to move y in front of x.

2.compareTo(5) == 1 , Then don't move 5 in front of 2.

ordre décroissant (y.compareTo (x)):

if y.compareTo(x) == 1, then y > x , since y is greater than x, you would have to move y in front of x.

5.compareTo(2) == -1 , Move 5 in front of 2.

Fondamentalement, nous déplacerons toujours y devant x, si le résultat de la méthode compareTo est 1.

8
Jay Modi

La méthode Collections.sort () le fait.

maintenant idk quel est exactement l'algorithme de sort () dans Java est, je crois que c'est un tri double fusionné modifié ... mais quelque part dans ce code compareTo (Comparable c) est appelé pour déterminer ce qui est supérieur/inférieur à, je vais essayer d'expliquer dans un algorithme plus simple:

disons que j'ai Circle, généralement vous compareriez les cercles par leur diamètre, donc ...

public class Circle implements Comparable<Cricle> {
 int diameter;
 //constructor
 public int compareTo(Circle c){
  return this.diameter-c.diameter;
   }

permet maintenant de créer un tableau de cercles:

ArrayList<Circle> collection = new ArrayList;
collection.add(new Circle(10)); // and more circles

supposons maintenant que c'est l'algorithme de tri défini dans Collection.sort ():

  Comparable tmp;
  for(int i=0;i<collection.size();i++){
   for(int j=i;j<collection.size();j++){
    if(collection.get(j).compareTo(collection.get(i)>0){
      //swap
      tmp=collection.get(i);
      collection.set(i,collection.get(j));
      collection.set(j,tmp);
     }
    }
   }

maintenant je ne suis pas sûr d'avoir écrit l'algorithme de tri écrire (asceding/descending) je viens de le faire rapidement, mais je suppose que le point est clair quant à la façon dont sort () décide ce qui va où ... vous pouvez demander en commentaire une explication supplémentaire

1
vlatkozelka