sort - ordenar lista de objetos por atributo java

Clasificación de Java: ordenar una matriz de objetos por propiedad, objeto no permitido para usar Comparable

Question

Tengo una clase, Biblioteca, que contiene una matriz de objetos Libro, y necesito ordenar la matriz en función de las propiedades de Libro, ya sea Título o Número de Página. El problema es que no puedo usar la clase Comparable con Libro. ¿Cómo recomendarías que ordenara la matriz de Libros en la biblioteca? Escribir mi propio tipo? ¿O hay una forma más fácil? Si necesita fragmentos de código, ¡solo pregunte!

Answer 1

Ampliando la respuesta de @ PeterLawrey a Java 8, ahora puede usar una expresión Lambda en lugar de un delegado Comparable<T> :

Collections.sort(books, (firstBook, secondBook -> b1 is greater return +1, 
                                                  if b2 is smaller return -1 otherwise 0));

Answer 2

Pegue esto en su Biblioteca:

java.util.Collections.sort(bookList, bookComparator);

Answer 3

crea un nuevo treeMap y cambia los roles entre clave y valor.

TreeMap<Title ,Book> treeMap = new TreeMap<Title,Book>();

Copie todos los datos al nuevo TreeMap.

Ahora tiene una colección ordenada basada en el Título. (Y no se requiere comparador :))

Answer 4

Si puede usar Comparators , escriba uno para cada tipo de clasificación que necesite, por ejemplo, ascendente para el título del libro y descendente para el número de página. El método de compare de un Comparator debe devolver positivo si el primer argumento es más grande que el segundo, negativo si el primero es más pequeño y cero si son iguales.

import java.util.Comparator;
import java.util.List;
import java.util.Arrays;

class Book{
    String title;
    int pageNumber;

    public Book(String title, int pageNumber){
        this.title = title;
        this.pageNumber = pageNumber;
    }

    String getTitle(){ return title; }
    int getPageNumber(){ return pageNumber; }

    public String toString(){
        return "(" + title + ", " + pageNumber + " pages)";
    }
}

public class Library{

    // These variables are static because you don''t need multiple copies
    // for sorting, as they have no intrinsic state.
    static private Comparator<Book> ascTitle;
    static private Comparator<Book> descPageNumber;

    // We initialize static variables inside a static block.
    static {
        ascTitle = new Comparator<Book>(){
            @Override
            public int compare(Book b1, Book b2){
                return b1.getTitle().compareTo(b2.getTitle());
            }
        };

        descPageNumber = new Comparator<Book>(){
            @Override
            public int compare(Book b1, Book b2){
                // Java 7 has an Integer#compare function
                return Integer.compare(b1.getPageNumber(), b2.getPageNumber());
                // For Java < 7, use 
                // Integer.valueOf(n1).compareTo(n2);
                // DO NOT subtract numbers to make a comparison such as n2 - n1.
                // This can cause a negative overflow if the difference is larger 
                // than Integer.MAX_VALUE (e.g., n1 = 2^31 and n2 = -2^31)
            }
        };
    }

    private Book[] books;
    public Book[] getBooks(){ return books; }

    public void sortAscTitle(){
        Arrays.sort(books, ascTitle);
    }

    public void sortDescPageNumber(){
        Arrays.sort(books, descPageNumber);
    }

    public Library(Book[] books){
        this.books = books;
    }

    public static void main(String[] args){
        Library library = new Library( new Book[]{
            new Book("1984", 123), 
            new Book("I, Robot", 152), 
            new Book("Harry Potter and the Philosopher''s Stone", 267),
            new Book("Harry Potter and the Goblet of Fire", 759),
            new Book("The Bible", 1623)
        });

        library.sortAscTitle();
        System.out.println(Arrays.toString(library.getBooks()));

        library.sortDescPageNumber();
        System.out.println(Arrays.toString(library.getBooks()));
    }
}

Answer 5

Puede proporcionar un Comparator para comparar cualquier tipo que desee, Comparable o no.

Para matrices y colecciones que usa

Arrays.sort(array, myComparator);
Collections.sort(list, myComparator);

Incluso colecciones ordenadas como TreeSet pueden tomar un Comparador personalizado

p.ej

Collections.sort(books, new Comparator<Book>() {
   public int compare(Book b1, Book b2) {
      return if b1 is greater return +1, if b2 is smaller return -1 otherwise 0
   }
});