Java Comparable
The Java Comparable interface, java.lang.Comparable , represents an object which can be compared to other objects. For instance, numbers can be compared, strings can be compared using alphabetical comparison etc. Several of the built-in classes in Java implements the Java Comparable interface. You can also implement the Java Comparable interface yourself, to make your own classes comparable.
When a class implements the Java Comparable interface, this means that instances (objects) of that class can be compared to each other, as mentioned above. When the objects can be compared, they can be sorted using the built-in sorting functionality in Java. This sorting functionality can be used to sort collections of Java objects.
Please keep in mind that the Comparable interface is intended for comparison of objects of the same class. In other words, comparing apples to apples and oranges to oranges. It is not intended to compare apples to oranges, or strings to numbers, dates to license plates etc.
Java Comparable Definition
The Java Comparable interface is located in the java.lang package. The Java Comparable interface definition looks like this:
package java.lang; public interface Comparable
As you can see, the Java Comparable interfaces only contains a single method. In the following section I will explain how the compareTo() method works.
compareTo()
The Java Comparable compareTo() method takes a single object as parameter and returns an int value. The int returned signal whether the object the compareTo() method is called on is larger than, equal to or smaller than the parameter object. More specifically:
- A positive value (1 or larger) signals that the object the compareTo() is called on is larger than the parameter object.
- A value of zero (0) signals that the two objects are equal.
- A negative value (-1 or smaller) signals that the object the compareTo() methods is called on is smaller than the parameter object.
Transitive Comparison
Note, that it is a requirement when implementing the Java Comparable interface, that the implementation respects the following transitive comparison characteristics:
If A is larger than B, and B is larger than C, then A must also be larger than C.
Java Comparable Example
To better illustrate how the Java Comparable interface works, let me show you a simple example. The Java Integer class implements the Comparable interface, so you can call compareTo() Here is an example:
public class ComparableExample < public static void main(String[] args) < Integer valA = Integer.valueOf(45); Integer valB = Integer.valueOf(99); int comparisonA = valA.compareTo(valB); int comparisonB = valB.compareTo(valA); System.out.println(comparisonA); System.out.println(comparisonB); >>
This example will print out the following lines:
Since the value 45 is smaller than 99 — the first comparison ( valA.compareTo(valB) = 45.compareTo(99) ) results in the value -1 being returned.
In the second comparison, when 99 is compared to 45 ( valB.compareTo(valA) = 99.compareTo(45) ) the result is 1 — because 99 is larger than 45.
Implementing the Java Comparable Interface
You can implement the Java Comparable interface yourself, if you need to. Here is an example of a Spaceship class which can compare itself to other Spaceship instances:
public class Spaceship implements Comparable < private String spaceshipClass = null; private String registrationNo = null; public Spaceship(String spaceshipClass, String registrationNo) < this.spaceshipClass = spaceshipClass; this.registrationNo = registrationNo; >@Override public int compareTo(Spaceship other) < int spaceshipClassComparison = this.spaceshipClass.compareTo(other.spaceshipClass); if(spaceshipClassComparison != 0) < return spaceshipClassComparison; >return this.registrationNo.compareTo(other.registrationNo); > >
Notice how this example implementation first compares the spaceShipClass and if they are the same, continues to compare on registrationNo. This way you can implement compareTo() to compare base on multiple factors.
Notice also how the implementation specifies that it implements Comparable and not just Comparable . By specifying a type parameter when implementing the Comparable interface, the compareTo() method parameter changes from Object to whatever type you have specified. In this case the type parameter is Spaceship — and thus the parameter type becomes Spaceship too.
An implementation without a type parameter would have looked like this:
public class Spaceship implements Comparable < private String spaceshipClass = null; private String registrationNo = null; public Spaceship(String spaceshipClass, String registrationNo) < this.spaceshipClass = spaceshipClass; this.registrationNo = registrationNo; >@Override public int compareTo(Object o) < Spaceship other = (Spaceship) o; int spaceshipClassComparison = this.spaceshipClass.compareTo(other.spaceshipClass); if(spaceshipClassComparison != 0) < return spaceshipClassComparison; >return this.registrationNo.compareTo(other.registrationNo); > >
Notice how there is no type parameter specified after the «implements Comparable» interface in the class declaration. Notice also, how the parameter type of the compareTo() object is no longer Spaceship, but Object. Finally, also notice how it is now necessary to cast the parameter of the compareTo() method to Spaceship explicitly.
Notice too, that the compareTo() method should throw a NullPointerException if the parameter object is null. This means you do not have to do a null check before comparing the objects.
Similarly, the compareTo() method should throw a ClassCastException if the input parameter is not of the same class as the class of the object compareTo() is called on. Thus, no explicit type check is necessary. You can just cast to the desired class (as in the example above). If the classes do not match, the Java VM will throw a ClassCastException.
Метод compareTo
Для упорядочивания объектов одного типа, хранящихся в массиве или коллекции, разработчики Java придумали интерфейс Comparable . В нём объявлен всего один метод, compareTo :
public interface Comparable
Интерфейс Comparable параметризирован типом объекта, который он принимает в качестве параметра в метод compareTo . В данном случае мы предупреждаем компилятор, какие типы объектов собираемся сравнивать. Если условие идентичности типов не будет выполняться, то мы получим ошибку ClassCastException . Метод compareTo в Java сравнивает вызывающий объект с объектом, переданным в качестве параметра, и возвращает в результате выполнения сравнения целое число:
- положительное, если вызывающий объект больше объекта, переданного в качестве параметра;
- отрицательное, если вызывающий объект меньше объекта, переданного в качестве параметра;
- нуль, если объекты равны.
Написание логики сравнения объектов – забота исключительно разработчика класса и определяется она желаемыми результатами при упорядочивании.
Зачем нужен метод compareTo в Java?
Программисту на Java очень часто приходиться иметь дело с массивами и списками объектов. При работе с большим количеством данных их зачастую удобно хранить в упорядоченном или отсортированном виде. Во-первых, это ускоряет работу с коллекцией при поиске нужной информации, во-вторых — упорядоченные данные визуально лучше воспринимаются.
Одним из самых простых и эффективных способов отсортировать массив объектов является метод sort() класса Arrays , а коллекцию объектов в виде списка – аналогичный метод класса Collections . Для сортировки с помощью этих методов разработчики Java предоставили нам свободу в выборе способа задания критериев сортировки: с реализацией интерфейса Comparable в классе объектов, которые мы хотим упорядочить, или с использованием интерфейса Comparator . В первом случае методы сортировки принимают набор объектов в виде массива или списка:
sort(T[]array)//сортировка массива sort(List list)// сортировка списка sort(T[]array, Comparator comparator)//сортировка массива sort(List list, Comparator comparator)// сортировка списка Интерфейс Comparable используется, когда мы хотим задать естественный (наиболее логичный с нашей точки зрения) порядок расположения объектов при сортировке. Он также является способом «зашить» алгоритм сравнения объектов этого класса на стадии его проектирования. Например, с помощью реализации этого интерфейса, определены критерии естественного упорядочивания в классах-обертках основных примитивных типов: Byte , Character , Long , Integer , Short , Double , Float , Boolean , String . Это также означает, что в этих классах есть реализованный метод compareTo , который при необходимости мы можем использовать в программе. Давайте посмотрим на примере сравнения строк, как реализован этот метод в классе String .
String str1="Аарон"; String str2="АAPOH"; String str3="аарон"; String str4="ААрон"; String str5="аАрон"; String str6="Берта"; String str7="берта"; String[] allStr=new String[]; Arrays.sort(allStr); for (String s:allStr) < System.out.println(s); >> АAPOH ААрон Аарон Берта аАрон аарон берта Как видно из примера в классе String , метод compareTo упорядочивает строки в алфавитном порядке, лексикографически и с учетом регистра. Именно такой порядок сравнения строк определен разработчиками класса String как естественный. Для более простого понимания, что такое лексикографический порядок, достаточно вспомнить, как расположены слова в языковых словарях. При сравнении чисел объекты упорядочиваются в порядке возрастания. Такая логика сравнения заложена в классах Byte , Character , Long , Integer , Shor , Double , Float .
Реализуем сравнение в своем классе
Посмотрим на примере как можно встроить возможность сравнения объектов в свой класс. При реализации метода compareto Java мы можем задать один или несколько критериев упорядочивания объектов, а также задействовать методы compareto из классов String и Integer . Например, для объектов класса User мы задаем сортировку по имени, а в случае равенства имен – по возрасту. Объекты будут располагаться в естественном порядке (по мере увеличения значения). Класс User :
public class User implements Comparable @Override //реализуем метод compareTo интерфейса Comparable public int compareTo(User o) < //используем метод compareTo из класса String для сравнения имен int result = this.name.compareTo(o.name); //если имена одинаковые - сравниваем возраст, используя метод compareTo из класса Integer if (result == 0) < result = this.age.compareTo(o.age); >return result; > @Override public String toString() < return "'; > Протестируем работу метода compareTo , реализованного в классе User , c помощью метода sort класса Collections :
public static void main(String[] args) < User user = new User("Андрей", 19, "andryha@mail.ru"); User user2 = new User("Олег", 25, "oleg@mail.ru"); User user3 = new User("Андрей", 24,"opr@google.com"); User user4 = new User("Игорь", 16, "igor@mail.ru"); User user5 = new User("Андрей", 44,"stary@google.com"); Listlist = new ArrayList<>(); list.add(user); list.add(user2); list.add(user3); list.add(user4); list.add(user5); System.out.println("-------до сортировки--------"); for (User u : list) < System.out.println(u); >System.out.println("-------после сортировки-----"); Collections.sort(list); for (User u : list) < System.out.println(u); >> > > ——-до сортировки——— ——-после сортировки——
Итак, подведем итог. Если вы — сторонник порядка во всем и хотите без лишнего кода расположить ваши объекты в массиве или списке – используете интерфейс Comparable . Реализация его метода compareTo позволяет достаточно легко встроить механизм естественного упорядочивания объектов вашего класса. Если вам приходится работать с коллекциями и массивами объектов стандартных классов, описанных в библиотеке Java, используйте уже готовые реализации compareTo в этих классах.