Teachnique
      CourseRoadmaps
      Login

      OverviewHistoryFeaturesJava 8 - New Featuresvs C++Virtual Machine(JVM)JDK vs JRE vs JVMHello World ProgramEnvironment SetupBasic SyntaxVariable TypesData TypesType CastingUnicode SystemBasic OperatorsCommentsStreamsNew Date-Time API

      Loop ControlDecision Makingif-else Statementswitch statementfor loopfor each Loopwhile Loopdo...while Loopbreak Statementcontinue Statement

      OOPs (Object-Oriented Programming) ConceptsObject and ClassesClass AttributesClass MethodsMethodsVariable ScopesConstructorsAccess ModifiersInheritanceAggregationPolymorphismOverridingMethod OverloadingDynamic BindingStatic BindingInstance Initializer BlockAbstractionEncapsulationInterfacesPackagesInner classesStatic ClassesAnonymous ClassesSingleton ClassWrapper ClassesEnum Class

      Number ClassBoolean classCharacter ClassArraysMath Class

      File ClassCreating FilesWrite To FilesReading FileDelete FilesDirectory OperationsFiles and I/O

      ExceptionsTry Catch BlockTry with ResourcesMultiple Catch BlocksNested Try BlockFinally BlockThrows and Throw | Throw an ExceptionException PropagationBuilt-in ExceptionsCustom Exception

      MultithreadingThread Life CycleCreating a ThreadStarting a ThreadJoining ThreadsNaming a Thread with ExamplesScheduling Threads with ExamplesThread PoolsMain ThreadThread PriorityDaemon ThreadThreadGroup ClassJVM Shutdown Hook

      Thread SynchronizationBlock SynchronizationStatic SynchronizationInter Thread CommunicationThread DeadlockInterrupting ThreadThread ControlReentrant Monitor

      NetworkingSocket ProgrammingURL ProcessingURL ClassURLConnection ClassHttpURLConnection ClassSocket Class with ExamplesGenerics

      Collections FrameworkCollection Interface

      List InterfaceArrayList Class

      Queue InterfaceArrayDeque Class

      Map InterfaceSortedMap Interface

      Set InterfaceSortedSet Interface

      Data Structures Enumeration Interface BitSet Class

      How to Use Iterator?How to Use Comparator?How to Use Comparable?

      RecursionRegular ExpressionsSerializationString ClassJava Arrays - Class

      Feedback

      Submit request if you have any questions.

      Course
      How to Use Comparator?

      Java Tutorial

      This Java tutorial is tailored for newcomers, offering a journey from basic principles to complex Java programming techniques. Completing this tutorial equips you with a solid understanding of Java, preparing you for advanced learning. You'll emerge ready to tackle the challenges of becoming a top-tier software engineer, with the skills to innovate and excel in the vast world of software development.

      How to Use Comparator?

      Both TreeSet and TreeMap store elements in sorted order. However, it is the comparator that defines precisely what sorted order means.

      Java Comparator Interface

      In Java, the Comparator interface is a part of java.util package and it defines the order of the objects of user-defined classes.

      Methods of Comparator Interface

      The Comparator interface defines two methods: compare() and equals(). The compare() method, shown here, compares two elements for order

      The compare() Method

      int compare(Object obj1, Object obj2)
      obj1 and obj2 are the objects to be compared. This method returns zero if the objects are equal. It returns a positive value if obj1 is greater than obj2. Otherwise, a negative value is returned.
      By overriding compare(), you can alter the way that objects are ordered. For example, to sort in a reverse order, you can create a comparator that reverses the outcome of a comparison.

      The equals() Method

      The equals() method, shown here, tests whether an object equals the invoking comparator 
      boolean equals(Object obj)
      obj is the object to be tested for equality. The method returns true if obj and the invoking object are both Comparator objects and use the same ordering. Otherwise, it returns false.
      Overriding equals() is unnecessary, and most simple comparators will not do so.

      Comparator Interface to Sort a Custom Object

      In this example, we're using Comparator interface to sort a custom object Dog based on comparison criterias.

      Example

      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.Comparator;
      import java.util.List;
      
      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;
         }
      
         @Override
         public String toString() {
            return this.name + "," + this.age;
         }
      }
      
      public class ComparatorDemo {
      
         public static void main(String args[]) {
            // Takes a list o Dog objects
            List<Dog> list = new ArrayList<>();
      
            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
            System.out.println("Sorted by name:");
            // printing the sorted list of names
            System.out.print(list);
      
            // Sorts the array list using comparator
            Collections.sort(list, new Dog());
            System.out.println(" ");
      
            System.out.println("Sorted by age:");
            // printing the sorted list of ages
            System.out.print(list);
         }
      }

      Output

      Sorted by name:
      [Lacy,2, Roger,10, Shaggy,3, Tammy,1, Tommy,4] 
      Sorted by age:
      [Tammy,1, Lacy,2, Shaggy,3, Tommy,4, Roger,10]
      Note − Sorting of the Arrays class is as the same as the Collections.

      Comparator Interface to Reverse Sort

      In this example, we're using Comparator interface to reverse sort the Dog objects.

      Example 2

      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.Comparator;
      import java.util.List;
      
      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;
         }
      
         @Override
         public String toString() {
            return this.name + "," + this.age;
         }
      }
      
      public class ComparatorDemo {
      
         public static void main(String args[]) {
            // Takes a list o Dog objects
            List<Dog> list = new ArrayList<>();
      
            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, Collections.reverseOrder());   // Sorts the array list
            System.out.println("Sorted by name in reverse order:");
            // printing the sorted list of names
            System.out.print(list);
         }
      }

      Output

      Sorted by name in reverse order:
      [Tommy,4, Tammy,1, Shaggy,3, Roger,10, Lacy,2]
      In this example, we're using Comparator interface to sort String values in reverse order.

      Example 3

      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.List;
      
      public class ComparatorDemo {
      
         public static void main(String args[]) {
            // Takes a list o Dog objects
            List<String> list = new ArrayList<>();
      
            list.add("Shaggy");
            list.add("Lacy");
            list.add("Roger");
            list.add("Tommy");
            list.add("Tammy");
      
            Collections.sort(list, Collections.reverseOrder());   // Sorts the array list
            System.out.println("Sorted by name in reverse order:");
            // printing the sorted list of names
            System.out.print(list);
         }
      }

      Output

      Sorted by name in reverse order:
      [Tommy, Tammy, Shaggy, Roger, Lacy]