Use of comparator and comparable interface

[Sanjib Pal]

Hi All,

Could anybody please specify when we should use the comparable interface to sort the collection and when to use comparator interface? Since both of them are use for sort any collection. Please specify in details...

Thanks,
Sanjib

[Jesper de Jong]

To be able to use the Comparable interface, the class of the objects in the collection has to implement that interface. You might have for example a List of objects from a class that you don't control yourself - for example, a class that comes from some third-party library. You can't make that class implement Comparable easily (it would mean you'd have to change the source code of the third-party library, which is normally not a good idea).

To be able to sort the List anyway, you can implement your own Comparator and pass that to for example Collections.sort(list, comparator);. Your Comparator object can be separate from the objects that are in the List.

Another example is when you might want to sort the list in different ways. Suppose you have a Person class:

public class Person {
	private final String name;
	private final int age;

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}
}

Suppose that you have a List of Person objects, and that you at one time want to sort the List by name, but at another time sort the List by age. You could make class Person implement Comparable, but you can implement the compareTo() method in only one way.

By using Comparator, you could instead make different comparators, one that compares Person objects by name, and another one that compares them by age. If you want to sort by name, you use the first Comparator object, and if you want to sort by age you use the other Comparator object.

[Rob Spoor]

Comparable should be used for the natural ordering - an ordering that just seems logical. For numbers that numerical ordering, for Strings its lexicographical ordering, for a Person class it could be the last name first, first name second. Basically, an ordering you want by default.

Comparator should be used if you don't want a default natural ordering, you can't make your class Comparable (perhaps because you get it from a library) or you want a different way of ordering (e.g. on first name first, last name second for the Person class).

[Seetharaman Venkatasamy]

Jesper Young wrote:
By using Comparator, you could instead make different comparators, one that compares Person objects by name, and another one that compares them by age. If you want to sort by name, you use the first Comparator object, and if you want to sort by age you use the other Comparator object.

by this way, you can move the compare *logic* to a seperate class , which looks good .

[Sanjib Pal]

Hi all,

Thanks everybody. Those replays cleared my concepts.

Sanjib

[Venkata Krishn Rao Maddu]

Comparable interface is having compareTo() method and which is normally used for natural ordering.
Comparator interface is having compare() method which takes two arguments and it can be used whenever you want to sort objects based of more then one parameter.

Example:

Comparable Interface:

class Person implements Comparable {
  public String name;
  public String lName;


  public Person(String name, String lName){
     this.name=name;
     this.lName=lName;
  }
  public String getName(){
    return name;
  }
  public String getLName(){
    return lName;
  }

  public static void main(String arg[]){
     List myList = new ArrayList();

    myList.add(new Person("cc","aa"));
    myList.add(new Person("bb","bb"));
    myList.add(new Person("aa","cc"));
    Collections.sort(myList);
    Iterator <Person> ml = myList.iterator();
    while(ml.hasNext()){
     System.out.println("My name is "+ml.next().getName());
    }
  }
public int compareTo(Object o) {
	Person p = (Person)o;
    return this.name.compareTo(p.getName());

}
}

Comparator Interface:

class Person  {
  public String name;
  public String lName;


  public Person(String name, String lName){
     this.name=name;
     this.lName=lName;
  }
  public String getName(){
    return name;
  }
  public String getLName(){
    return lName;
  }

}
public class MyComparator implements Comparator{
  public static void main(String arg[]){
     List myList = new ArrayList();

    myList.add(new Person("cc","aa"));
    myList.add(new Person("bb","bb"));
    myList.add(new Person("aa","cc"));
    Collections.sort(myList,new MyComparator());
    Iterator <Person> ml = myList.iterator();
    while(ml.hasNext()){
    	Person p = ml.next();
     System.out.println("My name is "+p.getName()+ " " + p.getLName());
    }
  }

public int compare(Object o1, Object o2) {
	   Person p1 =(Person) o1;
	   Person p2 =(Person) o2;
	   String p1Name = p1.getName()+ " " +p1.getLName();
	   String p2Name = p2.getName()+ " " +p2.getLName();
	   return p1Name.compareTo(p2Name);

}
}

[SoniyaG Gupta]

Thanks it helps to clear the concept of comparable and comparator

[Campbell Ritchie]

Welcome to the Ranch

You will find more details here, here and here, as well as old threads on this forum.