in this tutorial, we will discuss java comparator and its examples.
What is Java Comparator?
Java Comparator is an interface for arranging Java objects. Summoned by “java.util.comparator,” Java Comparator analyzes two Java protests in a “compare(Object 01, Object 02)” group.
Utilizing configurable strategies, Java Comparator can contrast objects with profit a number based for a positive, equivalent or negative correlation. Since it isn’t constrained to looking at numbers, this can permit Java Comparator to be set up to request records one after another in order or numerically. With java.io.Serializable, Java comparator can likewise be utilized to effectively arrange serialized information structures.
Java Comparator is like the Comparable interface yet is expected for characterizing exchange sort orders where Comparable sorts by regular requesting, for example, lexicographic arranging.
Syntax
public int compare(Object obj1, Object obj2):
How to use Java Comparator?
Both TreeSet and TreeMap store components in the arranged request. Be that as it may, it is the comparator that characterizes unequivocally what arranged request implies.
The Comparator interface characterizes two techniques: compare( ) and equals( ). The compare( ) strategy, appeared, looks at two components for request −
The compare Method
int compare(Object obj1, Object obj2)
obj1 and obj2 are questioned be looked at. This strategy returns zero if the articles are equivalent. It restores positive esteem if obj1 is more noteworthy than obj2. Something else, negative esteem is returned.
By abrogating compare( ), you can modify how protests are requested. For instance, to sort backward request, you can make a comparator that switches the result of an examination.
The Equals Method
The equals( ) strategy, appeared, tests whether an article squares with the conjuring comparator −
boolean equals(Object obj)
obj is the article to be tried for fairness. The strategy returns genuine if obj and the summoning object are both Comparator articles and utilize a similar requesting. Else, it returns false.
Abrogating equals( ) is superfluous, and most straightforward comparators won’t do as such.
Java Comparator Example
import java.util.*;
class Dog implements Comparator<Dog>, Comparable<Dog> {
private String name;
private int age;
Dog() {
}
Dog(String n, int a) {
name = n;
age = a;
}
public String getDogName() {
return name;
}
public int getDogAge() {
return age;
}
// Overriding the compareTo method
public int compareTo(Dog d) {
return (this.name).compareTo(d.name);
}
// Overriding the compare method to sort the age
public int compare(Dog d, Dog d1) {
return d.age - d1.age;
}
}
public class Example {
public static void main(String args[]) {
// Takes a list o Dog objects
List<Dog> list = new ArrayList<Dog>();
list.add(new Dog("Shaggy", 3));
list.add(new Dog("Lacy", 2));
list.add(new Dog("Roger", 10));
list.add(new Dog("Tommy", 4));
list.add(new Dog("Tammy", 1));
Collections.sort(list); // Sorts the array list
for(Dog a: list) // printing the sorted list of names
System.out.print(a.getDogName() + ", ");
// Sorts the array list using comparator
Collections.sort(list, new Dog());
System.out.println(" ");
for(Dog a: list) // printing the sorted list of ages
System.out.print(a.getDogName() +" : "+ a.getDogAge() + ", ");
}
}
OUTPUT:
Lacy, Roger, Shaggy, Tammy, Tommy, Tammy : 1, Lacy : 2, Shaggy : 3, Tommy : 4, Roger : 10,
Working Examples of Java comparator.
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Comparator;
class Student {
// instance member variables
String Name;
int Age;
// parameterized constructor
public Student(String Name, Integer Age) {
this.Name = Name;
this.Age = Age;
}
public String getName() {
return Name;
}
public void setName(String Name) {
this.Name = Name;
}
public Integer getAge() {
return Age;
}
public void setAge(Integer Age) {
this.Age = Age;
}
// overriding toString() method
@Override
public String toString() {
return "Customer{" + "Name=" + Name + ", Age=" + Age + '}';
}
static class CustomerSortingComparator implements Comparator<Student> {
@Override
public int compare(Student customer1, Student customer2) {
// for comparison
int NameCompare = customer1.getName().compareTo(customer2.getName());
int AgeCompare = customer1.getAge().compareTo(customer2.getAge());
// 2-level comparison using if-else block
if (NameCompare == 0) {
return ((AgeCompare == 0) ? NameCompare : AgeCompare);
} else {
return NameCompare;
}
}
}
public static void main(String[] args) {
// create ArrayList to store Student
List<Student> al = new ArrayList<>();
// create customer objects using constructor initialization
Student obj1 = new Student("Ajay", 27);
Student obj2 = new Student("Sneha", 23);
Student obj3 = new Student("Simran", 37);
Student obj4 = new Student("Ajay", 22);
Student obj5 = new Student("Ajay", 29);
Student obj6 = new Student("Sneha", 22);
// add customer objects to ArrayList
al.add(obj1);
al.add(obj2);
al.add(obj3);
al.add(obj4);
al.add(obj5);
al.add(obj6);
// before Sorting arraylist: iterate using Iterator
Iterator<Student> custIterator = al.iterator();
System.out.println("Before Sorting:\n");
while (custIterator.hasNext()) {
System.out.println(custIterator.next());
}
// sorting using Collections.sort(al, comparator);
Collections.sort(al, new CustomerSortingComparator());
// after Sorting arraylist: iterate using enhanced for-loop
System.out.println("\n\nAfter Sorting:\n");
for (Student customer : al) {
System.out.println(customer);
}
}
}
Output:
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc Sorted by name 131 aaaa nyc 111 bbbb london 121 cccc jaipu
