Interfaz comparable en Java con ejemplo

Interfaz comparable se utiliza principalmente para ordenar matrices (o listas) de archivos artículos personalizados.
Las listas (y matrices) de objetos que implementan la interfaz Comparable se pueden ordenar automáticamente por Collections.sort (y Arrays.sort). Antes de ver cómo ordenar un objeto de objetos personalizados, veamos cómo podemos ordenar elementos de matrices y clases contenedoras que ya implementan Comparable.

Ejemplo: clasificación de matrices y clase contenedora

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Demo {
  public static void main(String[] args) {
    /*
     * Integer class implements Comparable
     * Interface so we can use the sort method
     */
    int[] arr = {11,55,22,0,89};
    Arrays.sort(arr);
    System.out.print("Sorted Int Array: ");
    System.out.println(Arrays.toString(arr));
        
    /*
     * String class implements Comparable
     * Interface so we can use the sort method
     */
    System.out.print("Sorted String Array: ");
    String[] names = {"Steve", "Ajeet", "Kyle"};
    Arrays.sort(names);
    System.out.println(Arrays.toString(names));
        
     /*
      * String class implements Comparable
      * Interface so we can use the sort method
      */
     System.out.print("Sorted List: ");
     List fruits = new ArrayList();
     fruits.add("Orange");
     fruits.add("Banana");
     fruits.add("Apple");
     fruits.add("Guava");
     fruits.add("Grapes");
     Collections.sort(fruits);
     for(String s: fruits) System.out.print(s+", ");
  }
}

Producción:

Sorted Int Array: [0, 11, 22, 55, 89]
Sorted String Array: [Ajeet, Kyle, Steve]
Sorted List: Apple, Banana, Grapes, Guava, Orange, 

En el ejemplo anterior, ha visto lo fácil que es ordenar matrices y la lista de objetos que implementa la interfaz Comparable, solo necesita llamar a Collections.sort (y Arrays.sort).
Sin embargo, si desea ordenar los objetos de la clase personalizada, debe implementar la interfaz Comparable en nuestra clase personalizada.

Esta interfaz tiene un solo método que es:

public abstract int compareTo(T obj)

Dado que este método es abstracto, debe implementarse en la clase si está implementando la interfaz Comparable.

Tomemos un ejemplo para entenderlo mejor:

Ejemplo: ordenar objetos personalizados implementando la interfaz Comparable

Como puede ver, he implementado la interfaz Comparable en la mía Author class porque quiero ordenar los objetos de esta clase. Escribí la lógica de clasificación en el método compareTo (), puede escribir la lógica de acuerdo con el requisito. Quería ordenar los nombres de los autores primero por apellido y si el apellido es el mismo, entonces por nombre. Si desea ordenar solo por apellido, la primera línea dentro del método compareTo () es suficiente.

Clase del autor

public class Author implements Comparable<Author> {

  String firstName;
  String lastName;
  String bookName;
  Author(String first, String last, String book){
	this.firstName = first;
	this.lastName = last;
	this.bookName = book;
  }
	
  @Override
  /*
   * This is where we write the logic to sort. This method sort 
   * automatically by the first name in case that the last name is 
   * the same.
   */
  public int compareTo(Author au){
     /* 
      * Sorting by last name. compareTo should return < 0 if this(keyword) 
      * is supposed to be less than au, > 0 if this is supposed to be 
      * greater than object au and 0 if they are supposed to be equal.
      */
     int last = this.lastName.compareTo(au.lastName);
     //Sorting by first name if last name is same d
     return last == 0 ? this.firstName.compareTo(au.firstName) : last;
  }
}

Clase de clasificación: SortAuthByNames

import java.util.ArrayList;   
import java.util.Collections;
public class SortAuthByNames{  
   public static void main(String args[]){  
      // List of objects of Author class
      ArrayList<Author> al=new ArrayList<Author>(); 
      al.add(new Author("Henry","Miller", "Tropic of Cancer"));  
      al.add(new Author("Nalo","Hopkinson", "Brown Girl in the Ring"));
      al.add(new Author("Frank","Miller", "300"));
      al.add(new Author("Deborah","Hopkinson", "Sky Boys"));
      al.add(new Author("George R. R.","Martin", "Song of Ice and Fire"));
      
      /*
       * Sorting the list using Collections.sort() method, we
       * can use this method because we have implemented the 
       * Comparable interface in our user defined class Author
       */
      Collections.sort(al);  
      for(Author str:al){  
    	  System.out.println(str.firstName+" "+
          str.lastName+" "+"Book: "+str.bookName);  
      } 
   }  
}  

Producción:

Deborah Hopkinson Book: Sky Boys
Nalo Hopkinson Book: Brown Girl in the Ring
George R. R. Martin Book: A Song of Ice and Fire
Frank Miller Book: 300
Henry Miller Book: Tropic of Cancer

Nota: debemos escribir el método compareTo () de manera que si esto (me refiero a la palabra clave this aquí) es menor que el objeto pasado, debe devolver negativo si es mayor que positivo y cero si es igual.

Quizás se pregunte por qué no escribí esa lógica. Dado que el nombre y el apellido son cadenas, llamé al método compareTo () de la clase cadena, que hace exactamente lo mismo.

Sin embargo, si las cosas que estamos comparando son de otro tipo como int, puede escribir la lógica de esta manera:
Digamos que el objeto de la clase Empleado es (empId, empName, empAge) y queremos ordenar los objetos por empAge.

public int compareTo(Employee e){  
   if(this.empAge==e.empAge)  
      return 0;  
   else if(this.empAge>e.empAge)  
      return 1;  
   else  
      return -1;  
}

o

public int compareTo(Employee e){  
return this.empAge > e.empAge ? 1 : this.empAge < e.empAge ? -1 : 0;
}