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 Comparable?

      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 Comparable?

      Java Comparable Interface

      Comparable interface is a very important interface which can be used by Java Collections to compare custom objects and sort them. Using comparable interface, we can sort our custom objects in the same way how wrapper classes, string objects get sorted using Collections sorting methods.
      Using comparable, we can make the elements as sortable.

      Comparable Interface Methods

      The Comparable interface defines a methods: compareTo(). The compareTo() method, shown here, compares the passed object for order −

      The compare() Method

      int compareTo(Object obj)
      obj is the object to be compared. This method returns zero if the objects are equal. It returns a positive value if current object is greater than obj. Otherwise, a negative value is returned.
      By overriding compareTo(), you can alter the way that objects are ordered. For example, to sort in a reverse order, you can implement a comparison method 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.

      Comparable Interface to Sort Custom Object

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

      Example

      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.List;
      
      class Dog implements 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) {
            // compare the name using alphabetical order   
            return (this.name).compareTo(d.name);
         }
      
         @Override
         public String toString() {
            return this.name + "," + this.age;
         }
      }
      
      public class ComparableDemo {
      
         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);
         }
      }

      Output

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

      Comparable Interface to Sort Custom Object in Reverse Order

      Example

      In this example, we're using Collections.reverseOrder() method to reverse sort the Dog objects.
      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.List;
      
      class Dog implements 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);
         }
      
         @Override
         public String toString() {
            return this.name + "," + this.age;
         }
      }
      
      public class ComparableDemo {
      
         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

      This will produce the following result 
      Sorted by name in reverse order:
      [Tommy,4, Tammy,1, Shaggy,3, Roger,10, Lacy,2]

      Example

      In this example, we're using Comparable interface to sort Dog objects based on their ages.
      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.List;
      
      class Dog implements 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.age - d.age;
         }
      
         @Override
         public String toString() {
            return this.name + "," + this.age;
         }
      }
      
      public class ComparableDemo {
      
         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 age:");
            // printing the sorted list by age
            System.out.print(list);
         }
      }

      Output

      This will produce the following result 
      Sorted by age:
      [Tammy,1, Lacy,2, Shaggy,3, Tommy,4, Roger,10]