Clasificación Java: ordenar una matriz de objetos por propiedad, no se permite el objeto 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

Puede proporcionar un Comparator para comparar cualquier tipo que desee, Comparable o de lo contrario.

para Arrays y Colecciones utiliza

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

colecciones Incluso clasificadas como TreeSet puede tomar un Comparador de encargo

por ejemplo,

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

Answer 2

palillo de esto en su Biblioteca:

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

Answer 3

Si puede utilizar Comparators, escribir uno para cada tipo de ordenación que necesita, por ejemplo, ascendiendo por título del libro y descendente de número de página. El método compare de 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 4

crean un nuevo treeMap y cambian los roles entre la clave y el valor.

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

copiar todos los datos a la nueva TreeMap.

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

Answer 5

Ampliación @ respuesta de PeterLawrey a Java 8, ahora se puede utilizar un Lambda Expression 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));