Java: the Comparable and Comparator interfaces

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.