I have seen classes which implement both Comparable and Comparator. What does this mean? Why would I use one over the other?
The text below comes from Comparator vs Comparable
Comparable
A comparable object is capable of comparing itself with another object. The class itself must implements the java.lang.Comparable
interface in order to be able to compare its instances.
Comparator
A comparator object is capable of comparing two different objects. The class is not comparing its instances, but some other class’s instances. This comparator class must implement the java.util.Comparator
interface.
Implementing Comparable
means "I can compare myself with another object." This is typically useful when there's a single natural default comparison.
Implementing Comparator
means "I can compare two other objects." This is typically useful when there are multiple ways of comparing two instances of a type - e.g. you could compare people by age, name etc.
Comparator
can't be implemented by Comparable
easily? I don't see much difference between them –
Presumptive Person
implement Comparable
, because you can't then change how two people are compared. –
Maori Person
. 2) The comparator, e.g. PersonAgeComparator
which is able to compare two different entities and decide which should come first in that particular sort order. 3) The sort code, which takes a collection of entities and a comparator, and sorts that collection using the comparator to determine the order. –
Maori Comparable lets a class implement its own comparison:
- it's in the same class (it is often an advantage)
- there can be only one implementation (so you can't use that if you want two different cases)
By comparison, Comparator is an external comparison:
- it is typically in a unique instance (either in the same class or in another place)
- you name each implementation with the way you want to sort things
- you can provide comparators for classes that you do not control
- the implementation is usable even if the first object is null
In both implementations, you can still choose to what you want to be compared. With generics, you can declare so, and have it checked at compile-time. This improves safety, but it is also a challenge to determine the appropriate value.
As a guideline, I generally use the most general class or interface to which that object could be compared, in all use cases I envision... Not very precise a definition though ! :-(
Comparable<Object>
lets you use it in all codes at compile-time (which is good if needed, or bad if not and you loose the compile-time error) ; your implementation has to cope with objects, and cast as needed but in a robust way.Comparable<Itself>
is very strict on the contrary.
Funny, when you subclass Itself to Subclass, Subclass must also be Comparable and be robust about it (or it would break Liskov Principle, and give you runtime errors).
java.lang.Comparable
To implement
Comparable
interface, class must implement a single methodcompareTo()
int a.compareTo(b)
You must modify the class whose instance you want to sort. So that only one sort sequence can be created per class.
java.util.Comparator
To implement Comparator interface, class must implement a single method
compare()
int compare (a,b)
- You build a class separate from class whose instance you want to sort. So that multiple sort sequence can be created per class.
Comparable
is for providing a default ordering on data objects, for example if the data objects have a natural order.
A Comparator
represents the ordering itself for a specific use.
Comparable
is usually preferred. But sometimes a class already implements Comparable
, but you want to sort on a different property. Then you're forced to use a Comparator
.
Some classes actually provide Comparators
for common cases; for instance, String
s are by default case-sensitive when sorted, but there is also a static Comparator
called CASE_INSENSITIVE_ORDER
.
here are few differences between Comparator and Comparable I found on web :
If you see then logical difference between these two is Comparator in Java compare two objects provided to him, while Comparable interface compares "this" reference with the object specified.
Comparable in Java is used to implement natural ordering of object. In Java API String, Date and wrapper classes implement Comparable interface.
If any class implement Comparable interface in Java then collection of that object either List or Array can be sorted automatically by using Collections.sort() or Array.sort() method and object will be sorted based on there natural order defined by CompareTo method.
Objects which implement Comparable in Java can be used as keys in a sorted map or elements in a sorted set for example TreeSet, without specifying any Comparator.
site:How to use Comparator and Comparable in Java? With example
Read more: How to use Comparator and Comparable in Java? With example
Comparable
is for objects with a natural ordering. The object itself knows how it is to be ordered.
Comparator
is for objects without a natural ordering or when you wish to use a different ordering.
Difference between Comparator and Comparable interfaces
Comparable
is used to compare itself by using with another object.
Comparator
is used to compare two datatypes are objects.
If you see then logical difference between these two is Comparator
in Java compare two objects provided to him, while Comparable
interface compares "this" reference with the object specified.
Comparable
in Java is used to implement natural ordering of object. In Java API String, Date and wrapper classes implement Comparable
interface.
If any class implement Comparable
interface in Java then collection of that object either List
or Array
can be sorted automatically by using Collections.sort()
or Array.sort()
method and object will be sorted based on there natural order defined by compareTo
method.
Objects which implement Comparable
in Java can be used as keys in a sorted map or elements in a sorted set for example TreeSet
, without specifying any Comparator
.
My annotation lib for implementing Comparable and Comparator:
public class Person implements Comparable<Person> {
private String firstName;
private String lastName;
private int age;
private char gentle;
@Override
@CompaProperties({ @CompaProperty(property = "lastName"),
@CompaProperty(property = "age", order = Order.DSC) })
public int compareTo(Person person) {
return Compamatic.doComparasion(this, person);
}
}
Click the link to see more examples. compamatic
© 2022 - 2024 — McMap. All rights reserved.