objects - Comparador de Java usando.reverseOrder() pero con una clase interna

sort arraylist object java

Question

Estoy creando un programa simple para aprender acerca de la clase de Java Comparator. He ordenado un Arraylist en orden, pero ahora quiero ordenar la lista en orden descendente, pero tengo problemas para llamar al método .reverseOrder() , ya que he usado una clase interna que implementa Comparator<Song> (la canción es una canción clase que alberga los métodos de captadores y setter).

Aquí está mi clase SongSort que alberga el proceso de clasificación, 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);

    }

}

Y aquí está mi clase de Song simple;

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

¿Puede alguien ayudarme a averiguar dónde llamaré al método reverseOrder() en la clase SongSort , ya que no se compilará?

Answer 1

Si necesita usar un comparador que invierta el orden actual, simplemente devuelva un valor negativo en el método de compare .

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

Answer 2

Tomemos un ejemplo simple: tenemos una persona de clase con el nombre de dos campos edad y queremos clasificar una colección existente de personas según su edad, así que supongamos que tenemos una persona de clase con un constructor y agregamos a las personas a la lista y luego Clasifíquelos sin el método de colección:

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

y esta esta la impelemtación de Agecomparable:

class AgeComparator implements Comparator<Person>{


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


}

el truco es multiplicar el método de retorno con -1 para que el resultado final se invierta: la clase AgeComparator implementa el Comparador {

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


}

Así que ahora podemos obtener un resultado invertido:

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

Answer 3

Una forma de implementar un comparador de orden inverso es implementar un Compartor-Delegado que invierta el resultado del comparador (cambiando el orden).

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

Entonces, lo único que debe hacer es usar este delegado. Por ejemplo:

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

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

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

Answer 4

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

Edición Julio 2015

Como esta respuesta aún recibe atención, aquí hay una pequeña actualización:

Con Java SE 8 es cada vez más fácil crear un comparador invertido:

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

Y, por supuesto, también puede utilizar el marco Streams:

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