Java en utilisant le Comparateur de .reverseOrder() mais avec un intérieur de classe

Je suis entrain de créer un programme simple pour apprendre le Java Comparateur de classe. J'ai trié un Arraylist dans l'ordre, mais maintenant, je veux trier la liste dans l'ordre décroissant, mais éprouve des difficultés dans l'endroit où l'appel de la .reverseOrder() méthode que j'ai utilisé un intérieur classe qui implémente Comparator<Song> (chanson une chanson de la classe qui abrite des accesseurs et des mutateurs).

Voici mon SongSort classe qui abrite le processus de tri, etc.;

import java.util.*;
import java.io.*;
public class SongSort
{
ArrayList<Song> songList = new ArrayList<Song>();
public void main(String[] args)
{
new SongSort().go();
}
class ArtistCompare implements Comparator<Song>
{
public int compare(Song one, Song two)
{
return one.getRating().compareTo(two.getRating());
}
}
public void go()
{
getSongs();
System.out.println(songList);
//Collections.sort(songList); 
System.out.println(songList);
ArtistCompare artistCompare = new ArtistCompare();
Collections.sort(songList, artistCompare);
System.out.println(songList);
}
public void getSongs()
{
try{
File file = new File("SongListMore.txt");
BufferedReader reader = new BufferedReader(new FileReader(file));
String line = null;
while((line = reader.readLine()) != null)
{
addSong(line);
}
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
public void addSong(String lineToParse)
{
String [] tokens = lineToParse.split("/");
Song nextSong = new Song(tokens[0],  tokens[1], tokens[2], tokens[3]);
songList.add(nextSong);
}
}

Et voici mon simple Song classe;

public class Song //implements Comparable<Song>
{
private String title;
private String artist;
private String rating;
private String bpm;
public Song(String t, String a, String r, String b)
{
title = t;
artist = a;
rating = r;
bpm = b;
}
public String getTitle()
{
return title;
}
public String getArtist()
{
return artist;
}
public String getRating()
{
return rating;
}
public String getBpm()
{
return bpm;
}
public String toString()
{
return ("Title : " + title + "," +  " Artist : " + artist +  " Rating : " + rating);
}
}

Quelqu'un peut-il m'aider à comprendre où je vais appeler la reverseOrder() méthode dans le SongSort classe, comme il ne compile pas?

InformationsquelleAutor James Morrison | 2011-04-26
  1. 79
    ArtistCompare artistCompare = new ArtistCompare();
Collections.sort(songList, Collections.reverseOrder(artistCompare));

    Modifier Juillet 2015

    Que cette réponse obtient encore un peu d'attention, voici une petite mise à jour:

    Avec Java SE 8 il est de plus en plus facile de créer une inversion de comparateur:

    Comparator<Song> songRatingComparator = Comparator.comparing(Song::getRating);
Collections.sort(songList, songRatingComparator.reversed());

    Et vous pouvez aussi, bien sûr, utiliser les cours d'eau du cadre:

    List<Song> sortedSongList = songList.stream()
.sorted(Comparator.comparing(Song::getRating).reversed())
.collect(Collectors.toList());
    • Que faire si je veux créer comparateur de par 2 champs en double champ croissant et par champ de type chaîne de descente?
    • Veuillez consulter la Javadoc. Il existe des méthodes similaires pour double propriétés (comparingDouble, thenComparingDouble) et il y a des méthodes surchargées où vous pouvez passer d'autres Comparateurs tels que reverseOrder())
    InformationsquelleAutor Puce
  2. 5

    Une façon de mettre en œuvre un ordre inverse comparateur de mettre en place un Compartor-Délégué qui inversent le comparateur de résultat (par modification de l'ordre).

    public class ReverseOrder<T> implements Comparator<T> {
private Comparator<T> delegate;
public ReverseOrder(Comparator<T> delegate){
this.delegate = delegate;
}
public int compare(T a, T b) {
//reverse order of a and b!!!
return this.delegate.compare(b,a);
}
}

    La seule chose que vous devez faire est d'utiliser ce délégué.
    Par exemple:

      Comparator myComparator = new myComparator();
List list = ...;
List reverse = new ArrayList(list);
//acceding
Collections.sort(list, myComparator);
//descending
Collections.sort(list, new ReverseOrder(myComparator));
    • java.utils.Les Collections.reverseOrder(Comparateur c) faire de même et de inverser la comparaison de votre comparateur. Donc, vous ne devriez pas réinventer la roue, mais l'utilisation de l'API Java SE.
    • C'est pourquoi la Puce réponse est la réponse. - De toute façon je ne vais pas supprimer cette réponse, car elle est valide.
    • J'aime cette réponse, car il est plus robuste, et les Comparateurs ont plus d'utilisations expressément que le tri des listes existantes. Par exemple, j'ai été en mesure de faire usage de cette dans un TreeMap(Comparateur) de la construction, qui est un SortedMap.
    • Les Collections.reverseOrder retourne un Comparateur de...
    InformationsquelleAutor Ralph
  3. 4

    Prenons un exemple simple, nous avons une Personne de la classe avec deux champs nom de l'âge et nous voulons trier une collection existante de personnes en fonction de leur âge supposons donc que nous avons une Personne de la classe avec un constructeur et d'ajouter les personnes dans la liste, puis de les trier unsing la méthode de tri de la collecte :

    Person bachiri = new Person (17,"bachiri");
Person taoufiq = new Person (14,"Taoufiq");
Person abderrahman = new Person (15,"abderrahman");
List<Person> persons =  new ArrayList<>();

    et ce, le impelemtation de Agecomparable :

    class AgeComparator implements Comparator<Person>{
@Override
public int compare(Person person1, Person person2) {
return Integer.compare(person1.getAge(),person2.getAge());
}
}

    le truc, c'est pour plusieurs le retour de la méthode avec -1 de sorte que le résultat final sera inversé:
    classe AgeComparator implémente Comparateur{

        @Override
public int compare(Person person1, Person person2) {
return -1 * Integer.compare(person1.getAge(),person2.getAge());
}
}

    alors maintenant, nous pouvons obtenir un résultat inversé :

    Collection.sort (Persons, new AgeComparator());
    • Je viens de voir @Ralph réponse c'est pratique, vous pouvez eighter basculer les paramètres a,b ou écrire return -1 *this.delegate.compare(a,b);
    InformationsquelleAutor Bachiri Taoufiq Abderrahman
  4. -7

    Si vous avez besoin d'utiliser un Comparateur qui annule la commande en cours, il suffit de retourner un valeur négative dans le compare méthode.

    public class ComparatorInverse implements Comparator<Object> {
@Override
public int compare(Object lhs, Object rhs) {
return -1;
}
}
    • Ce n'est pas correct. Jetez un oeil à la Javadoc: docs.oracle.com/javase/7/docs/api/java/util/...
    • Retourner une valeur fixe indépendant des arguments n'a pas de sens, pour ne pas mentionner l'ordre inverse de cas. Il suffit de l'échanger les arguments et maintenant elles sont classées dans un ordre différent - qui ne se traduira pas par un quelconque ordre stable du tout.
    • Je vois que je ne gardez pas les contraintes. Même si cela n'a aucun sens, ça fonctionne pour moi.
    • Je suppose que dans votre code que vous insérez d'abord les objets dans un ordre trié, dans quelque chose comme ArrayList qui maintient l'ordre d'insertion. Maintenant l'appel de tri sur cette liste avec le ComparatorInverse appellera compare() dans une partie fixe et de manière prévisible avec toujours lhs < rhs. Puis de retour -1 renverse cet ordre. Mais si vous insérez vos éléments (dire des nombres au hasard ou de l'algorithme de tri des changements, il ne sera plus à même de produire les meilleurs résultats en termes de naturel de tri oder quelle que soit Object est.
    • Oui les articles sont dans l'ordre - Dans ma solution, j'ai écrit à renverser l'ordre actuel. Les Collections.méthode sort() va appeler une mergesort qui passe de tous les éléments dans le tri (en renvoyant -1). Et bien sûr, vous avez raison si ils vont changer l'algorithme de tri, il peut louper 🙂 - il n'est donc pas correcte.
    InformationsquelleAutor marnaish