Блог

Я создаю простую программу, чтобы узнать о классе Java Comparator. Я отсортировал Arraylist по порядку, но теперь я хочу отсортировать список в порядке убывания, но у меня возникли проблемы с тем, где вызвать .reverseOrder() метод, поскольку я использовал внутренний класс, который реализует Comparator<Song> (song — это класс song, в котором находятся методы получения и установки).

Вот мой SongSort класс, в котором находится процесс сортировки и т.д.;

 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);

    }

}
  

И вот мой простой 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);
    }
}
  

Кто-нибудь может помочь мне выяснить, где я буду вызывать reverseOrder() метод в SongSort классе, поскольку он не будет компилироваться?

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

Редактировать Июль 2015

Поскольку этот ответ все еще привлекает некоторое внимание, вот небольшое обновление:

С Java SE 8 становится проще создавать обратный компаратор:

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

И вы, конечно, также можете использовать Streams framework:

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

Одним из способов реализации компаратора обратного порядка является реализация делегата-компаратора, который инвертирует результат компаратора (путем изменения порядка).

 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);
  }
}
  

Итак, единственное, что вам нужно сделать, это использовать этот делегат.
Например:

   Comparator myComparator = new myComparator();
  List list = ...;
  List reverse = new ArrayList(list);

  //acceding
  Collections.sort(list, myComparator);

  //descending
  Collections.sort(list, new ReverseOrder(myComparator));
  

Давайте возьмем простой пример, у нас есть класс Person с двумя полями name age, и мы хотим отсортировать существующую коллекцию людей на основе их возраста, поэтому давайте предположим, что у нас есть класс Person с конструктором и добавим людей в список, а затем отсортируем их, не используя метод sort of collection :

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

и это это побуждение Agecomparable :

 class AgeComparator implements Comparator<Person>{


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


}
  

хитрость заключается в том, чтобы умножить возвращаемый метод на -1, чтобы конечный результат был обратным:
класс AgeComparator реализует компаратор{

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


}
  

итак, теперь мы можем получить обратный результат :

 Collection.sort (Persons, new AgeComparator());
  

Если вам нужно использовать компаратор, который изменяет текущий порядок, просто верните отрицательное значение в compare методе.

 public class ComparatorInverse implements Comparator<Object> {
   @Override
   public int compare(Object lhs, Object rhs) {
      return -1;
   }
}