Question

我正在创建一个简单的程序来了解Java Comparator类。我已将Arraylist按顺序排序，但现在我想按降序对列表进行排序，但我在调用.reverseOrder()方法时遇到问题，因为我使用了一个实现{{1}的内部类（歌曲是一个包含getter和setter方法的歌曲类。）

这是我的Comparator<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()方法，因为它不会编译吗？

Answer 1

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

2015年7月编辑

由于这个答案仍然受到一些关注，这里有一个小小的更新：

使用Java SE 8，创建反向比较器变得更加容易：

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

当然，您也可以使用Streams框架：

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

Answer 2

实现逆序比较器的一种方法是实现一个反转比较器结果的Compartor-Delegate（通过改变顺序）。

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

Answer 3

让我们举一个简单的例子，我们有一个Person，它有两个字段名称age，我们希望根据它们的年龄对现有的人员集合进行排序，所以让我们假设我们有一个带有构造函数的Person，并将这些人添加到列表，然后排序他们没有方法的集合类型：

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复用return方法，以便最终结果反转： class AgeComparator实现Comparator {

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


}

所以现在我们可以得到相反的结果：

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

Answer 4

如果您需要使用反转当前订单的比较器，只需在compare方法中返回负值。

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

Java Comparator使用.reverseOrder（）但内部类

4 个答案: