The Comparable interface allows you to sort by a specific object variable that you choose for your needs.
Take a look at the following object:
public class Book implements Comparable<Book> {
private String title;
private String author;
private double price;
public Book(String title, String author, double price) {
super();
this.title = title;
this.author = author;
this.price = price;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
@Override
public int compareTo(Book that) {
return Double.valueOf(this.price).compareTo(Double.valueOf(that.price));
}
public String toString() {
return " \n " + title + " \t " + author + " \t " + price;
}
}
Notice the way the compareTo method is overriden. It´s a double primitive variable, but you need the wrapper class to compare it. The following wouldn´t work:
@Override
public int compareTo(Book that) {
return this.price.compareTo(that.price);
return 0;
}
Implementing the Comparable interface affects the sorting criteria. For example:
import java.util.Arrays;
public class ComparableTest{
public static void main(String[] args) {
Book[] books= {
new Book("The capital","Marx,Karl",10.5),
new Book("Interpretation of dreams","Freud, S.",12.5),
new Book("Killed by Death","Kilmister, Lemmy",8)
};
System.out.println("Before sorting: \n"+Arrays.toString(books));
Arrays.sort(books);
System.out.println("\n After sorting: \n"+Arrays.toString(books));
}
}
The output is:
Before sorting:
[
The capital Marx,Karl 10.5,
Interpretation of dreams Freud, S. 12.5,
Killed by Death Kilmister, Lemmy 8.0]
After sorting:
[
Killed by Death Kilmister, Lemmy 8.0,
The capital Marx,Karl 10.5,
Interpretation of dreams Freud, S. 12.5]
If you need to do a more complex comparison, you can make your own comparator by extending the Comparator interface (not “Comparable”).
For example you can create your own Comparator:
public class BookComparator implements Comparator<Book> {
@Override
public int compare(Book b1, Book b2) {
int comparePrice = Double.valueOf(b1.getPrice()).compareTo(Double.valueOf(b2.getPrice()));
if (comparePrice!=0)
{return comparePrice;
}
else return b1.getAuthor().compareTo(b2.getAuthor());
}
}
It tries to order by price first, but ifthe books have the same price, they will be sorted by the author name too.
If you runt the following main method:
public static void main(String[] args) {
ArrayList<Book> booksList = new ArrayList<Book>();
booksList.add(new Book("The capital", "Marx,Karl", 10.5));
booksList.add(new Book("Peace and War", "Tostoj. L.", 12.5));
booksList.add(new Book("Interpretation of dreams", "Freud, S.", 12.5));
booksList.add(new Book("Killed by Death", "Kilmister, Lemmy", 8));
System.out.println("before sorting:");
for (Book book : booksList) {
System.out.println( book.toString());
}
Collections.sort(booksList, new BookComparator());
System.out.println(""
+ "\n after sorting:");
for (Book book : booksList) {
System.out.println(book.toString());
}
Then you see the following output:
before sorting:
The capital Marx,Karl 10.5
Peace and War Tostoj. L. 12.5
Interpretation of dreams Freud, S. 12.5
Killed by Death Kilmister, Lemmy 8.0
after sorting:
Killed by Death Kilmister, Lemmy 8.0
The capital Marx,Karl 10.5
Interpretation of dreams Freud, S. 12.5
Peace and War Tostoj. L. 12.5
Notice the order of the last two books.
