web-dev-qa-db-fra.com

Java Comparateur utilisant .reverseOrder () mais avec une classe interne

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

Voici ma classe SongSort 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 ma simple classe Song;

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 à savoir où j'appellerai la méthode reverseOrder() dans la classe SongSort, car elle ne compilera pas?

javasortingcomparable
26
James Morrison
ArtistCompare artistCompare = new ArtistCompare();
Collections.sort(songList, Collections.reverseOrder(artistCompare));

Modifier juillet 2015

Comme cette réponse retient encore l'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 bien sûr également utiliser le framework Streams:

List<Song> sortedSongList = songList.stream()
.sorted(Comparator.comparing(Song::getRating).reversed())
.collect(Collectors.toList());
79
Puce

Une façon d'implémenter un comparateur d'ordre inverse consiste à implémenter un Compartor-Delegate 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));
5
Ralph

Prenons un exemple simple, nous avons une classe Personne avec deux champs nommés âge et nous voulons trier une collection existante de personnes en fonction de leur âge. Supposons donc que nous avons une classe Personne avec un constructeur et ajoutons les personnes dans la liste, puis trier les unsing le tri de la méthode 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 ceci c'est l'impelemtation d'Agecomparable:

class AgeComparator implements Comparator<Person>{


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


}

l'astuce consiste à multiplier la méthode de retour par -1 pour que le résultat final soit inversé: la classe AgeComparator implémente 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());
4
Bachiri Taoufiq Abderrahman