Java en utilisant le Comparateur de.reverseOrder () mais avec une classe intérieure

je crée un programme simple pour en savoir plus sur la classe Java Comparator. J'ai trié Arraylist dans l'ordre mais maintenant je veux trier la liste dans l'ordre décroissant mais j'ai des problèmes pour appeler le .reverseOrder() la méthode que j'ai utilisé un intérieur classe qui implémente Comparator<Song> (la chanson étant une classe de chanson qui abrite des getters et des méthodes de setter).

Voici mon SongSort classe qui héberge 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);
    }
}

est-ce que quelqu'un peut m'aider à trouver où je vais appeler le reverseOrder() méthode SongSort classe, comme il ne compile pas?

22
demandé sur Null 2011-04-26 15:17:01

4 réponses 

ArtistCompare artistCompare = new ArtistCompare();
Collections.sort(songList, Collections.reverseOrder(artistCompare));

Modifier Juillet 2015

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

avec Java SE 8, il devient plus facile de créer un comparateur inversé:

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());
71
répondu Puce 2015-09-17 14:54:32

une façon d'implémenter un comparateur d'ordre inverse est d'implémenter un Comparteur-délégué qui inverse le résultat du comparateur (en changeant 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);
  }
}

Donc 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));
4
répondu Ralph 2014-03-06 22:15:22

prenons un exemple simple nous avons une personne de classe avec deux champs Nom de l'âge et nous voulons trier une collection existante de personnes en fonction de leur âge donc supposons que nous avons une personne de classe avec un constructeur et ajouter les personnes dans la liste et puis les trier unsing la méthode sorte de collection :

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 ce la 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 est de multiplier la méthode de retour avec -1 donc le résultat final sera inverser: classe AgeComparator implements Comparator { 

    @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());
2
répondu Bachiri Taoufiq Abderrahman 2017-05-20 22:19:20

si vous avez besoin d'utiliser un comparateur qui inverse l'ordre courant, 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;
   }
}
-7
répondu marnaish 2013-05-08 18:37:24