Comparator Vs Comparable

[Saral Saxena]

Hi,

I am going through comparator and comparable, I have done lot of googling also, can you guys please explain in simple,very simple words that whats the use of both of them In which real life situation we should choose comparable and in which situation we should go for comparator..!! please if possible explain it with a small example..!!

[Haina Minawa]

Saral Saxena wrote:Hi,

I am going through comparator and comparable, I have done lot of googling also, can you guys please explain in simple,very simple words that whats the use of both of them In which real life situation we should choose comparable and in which situation we should go for comparator..!! please if possible explain it with a small example..!!

Well, things are simple:

- Comparator: A comparator compares two object together by the method: compare(Object1, Object2). The objects being compared do not have to aware about the comparison logic. This is suitable for the situation in which you don't want to modify the compared object class.

- Comparable: A comparable object must implement the compareTo(Object) method, the compared object is responsible for the comparison logic. In this way you have to write additional code for the compared objects.

[Rob Camick]

Here is my standard example showing the usage of both:

/*
**  Use the Collections API to sort a List for you.
**
**  When your class has a "natural" sort order you can implement
**  the Comparable interface.
**
**  You can use an alternate sort order when you implement
**  a Comparator for your class.
*/
import java.util.*;

public class Person implements Comparable<Person>
{
	String name;
	int age;

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

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}

	public String toString()
	{
		return name + " : " + age;
	}

	/*
	**  Implement the natural order for this class
	*/
	public int compareTo(Person p)
	{
		return getName().compareTo(p.getName());
	}

	static class AgeComparator implements Comparator<Person>
	{
		public int compare(Person p1, Person p2)
		{
			return p1.getAge() - p2.getAge();
		}
	}

	public static void main(String[] args)
	{
		List<Person> people = new ArrayList<Person>();
		people.add( new Person("Homer", 38) );
		people.add( new Person("Marge", 35) );
		people.add( new Person("Bart", 15) );
		people.add( new Person("Lisa", 13) );

		// Sort by natural order

		Collections.sort(people);
		System.out.println("Sort by Natural order");
		System.out.println("\t" + people);

		// Sort by reverse natural order

		Collections.sort(people, Collections.reverseOrder());
		System.out.println("Sort by reverse natural order");
		System.out.println("\t" + people);

		//  Use a Comparator to sort by age

		Collections.sort(people, new Person.AgeComparator());
		System.out.println("Sort using Age Comparator");
		System.out.println("\t" + people);

		//  Use a Comparator to sort by descending age

		Collections.sort(people, Collections.reverseOrder(new Person.AgeComparator()));
		System.out.println("Sort using Reverse Age Comparator");
		System.out.println("\t" + people);
	}
}

[Keith Rainey]

take a look at this explanation and see if it helps: Comparable & Comparator

[Roberto Perillo]

How about the Object Ordering tutorial?

[Thomas Kennedy]

Implementing Comparable on your class lets you sort objects of that class in one way, by sticking on a compareTo(Object o) method. Note that you have to modify the class to do this, so it won't work if the class is final. And it's no help if you need to sort multiple ways.

Implementing Comparator means you leave your own class alone and instead create at least one new class. This class implements Comparator. Each Comparator sorts your objects its own way. So you can have a MonkeysByCuriosityAscending class and a MonkeysByCuriosityDescending class. Use the one that sorts the way you want.

Note the following detail of Rob's example. He used a generic type on his Comparable declaration: public class Person implements Comparable<Person>

That lets him do this:

public int compareTo(Person p)   
    {   
        return getName().compareTo(p.getName());   
    }

If he had not used a generic he would have had to say public int compareTo(Object o) and then have done some ugly casts inside the method to check if it's really a Person he's dealing with.