Comparable and Comparator interfaces-Part 1

I have tried to make the article to be detailed and at the same time to the point.
 Comparable: It is an interface.If your class implements it object of your class can be compared with other objects of the same class. To compare you must implement the compareTo method in your class. compareTo must be consistent with the equals method (but not mandatory). For further details please refer to Comparable documentation.
    compareTo(Object o): Can be called like e1.compareTo(e2). Implementor should ensure following things:

1. It should return Negative integer (if e1 < e2), 0 (if e1 = e2), Positive integer (if e1 > e2)
2. It should throw ClassCastException if object types of e1 and e2 are not comparable
3. It should throw NullPointerException if e2 passed is null

 Comparator: It is again an interface only. It is also used to provide ordering but you need not modify the class to provide the ordering to it. It has a compare(Object e1, Object e2). You create a separate class which implements the Comparator interface and implement the compare method
which does the actual work.
    compare(Object e1, Object e2): Can be called like compare(e1, e2)

1. It should return Negative integer (if e1 < e2), 0 (if e1 = e2), Positive integer (if e1 > e2)
2. It should throw ClassCastException if object types of e1 and e2 are not comparable
3. It should throw NullPointerException if either e1 or e2 or both passed are null

Following are some classes in Java which implement comparable interface:
Note:

Class	Natural Ordering that the class has
Byte, Short, Integer, Long, Float, Double, BigInteger, BigDecimal	Signed numerical
Character	Unsigned numerical
Boolean	Boolean.True > Boolean.False
String	Lexographic
Date	Chronological
File	System-dependent lexicographic path name
CollationKey	Locale-specific lexicographic

Other classes implementing Comparable interface are URI, Charset, ByteBuffer, ShortBuffer, CharBuffer, IntBuffer, FloatBuffer, DoubleBuffer, LongBuffer

Example: Comparable
We has an Employee class which we need to store in a list in the ascending order of their name to display on the screen. Here goes the code for Employee class and Test class to check the ordering.

package blog.javaespresso.comparable.example.bean;

import java.util.Date;
public class Employee implements Comparable<employee>{
 public Employee(){}
 public Employee(int empId,String name,double salary,Date dateOfJoining){
  this.empId = empId;this.name =  name;
  this.salary =  salary;this.dateOfJoining = dateOfJoining;
 }
 private int empId;
 private String name;
 private double salary;
 private Date dateOfJoining;
 @Override
 public int compareTo(Employee o) {
  if(o == null){
   throw new NullPointerException("compareTo: Argument passed is null");
  }
  if(this.getClass().equals(o.getClass())){
   Employee e = (Employee) o;
   return this.getName().compareTo(e.getName());
  }else{
   throw new ClassCastException("compareTo: Objects are not comparable");
  }
 }
 // setters and getters
 public int getEmpId() {return empId;}
 public void setEmpId(int empId) {this.empId = empId;}
 public String getName() {return name;}
 public void setName(String name) {this.name = name;}
 public double getSalary() {return salary;}
 public void setSalary(double salary) {this.salary = salary;}
 public Date getDateOfJoining() {return dateOfJoining;}
 public void setDateOfJoining(Date dateOfJoining) {this.dateOfJoining = dateOfJoining;
}
}

Now let us see the test class:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import blog.javaespresso.comparable.example.bean.Employee;

public class TestEmployeeSorting {
 public static void main(String[] args) {
  Employee e1 = new Employee(1,"A",20000.00,new Date(2010,12,11));
  Employee e2 = new Employee(2,"A",22000.00,new Date(2009,12,11));
  Employee e3 = new Employee(3,"A",10000.00,new Date(1990,12,11));
  Employee e4 = new Employee(4,"F",19000.00,new Date(2001,12,11));
  Employee e5 = new Employee(5,"E",24000.00,new Date(2006,12,11));
  List<Employee> list = new ArrayList<Employee>();
  list.add(e1);list.add(e2);list.add(e3);list.add(e4);list.add(e5);
  // PRINT BEFORE SORTING
  System.out.println("BEFORE SORTING");
  System.out.println("===============================================================");
  System.out.println("ID  Name  Salary  Date Of Joining");
  System.out.println("===============================================================");
  for (Employee employee : list) {
   System.out.println(employee.getEmpId()+"\t\t "+employee.getName()
     +"\t\t"+employee.getSalary()+"\t\t "+
     employee.getDateOfJoining().getDay()+"-"+employee.getDateOfJoining().getMonth()
     +"-"+employee.getDateOfJoining().getYear());
  }

  // sorting the Employee object
  Collections.sort(list);
  // PRINT AFTER SORTING
  System.out.println("\n\nAFTER SORTING");
  System.out.println("===============================================================");
  System.out.println("ID  Name  Salary  Date Of Joining");
  System.out.println("===============================================================");
  for (Employee employee : list) {
   System.out.println(employee.getEmpId()+"\t\t "+employee.getName()
     +"\t\t"+employee.getSalary()+"\t\t "+
     employee.getDateOfJoining().getDay()+"-"+employee.getDateOfJoining().getMonth()
     +"-"+employee.getDateOfJoining().getYear());
  }
 }
}

To sort in the descending order of name, you just need to call reverse(List list) method of Collections class after doing sorting. For example,

Collections.sort(list);
Collections.reverse(list);
  // PRINT AFTER SORTING
  System.out.println("\n\nAFTER SORTING");

Related Articles
Comparable and Comparator interfaces-Part 2
Sorting objects with more than one attribute