¿Cómo implementar la interfaz comparable de Java?

No estoy seguro de cómo implementar una interfaz comparable en mi clase abstracta. Tengo el siguiente código de ejemplo que estoy usando para intentar entenderlo:

public class Animal{
    public String name;
    public int yearDiscovered;
    public String population;

    public Animal(String name, int yearDiscovered, String population){
        this.name = name;
        this.yearDiscovered = yearDiscovered;
        this.population = population; }

    public String toString(){
        String s = "Animal name: "+ name+"\nYear Discovered: "+yearDiscovered+"\nPopulation: "+population;
        return s;
    }
}

Tengo una clase de prueba que creará objetos de tipo Animal; sin embargo, quiero tener una interfaz comparable dentro de esta clase para que los años anteriores de descubrimiento tengan un rango más alto que bajo. Sin embargo, no tengo idea de cómo hacerlo.

Solo tienes que definir eso Animal implements Comparable<Animal>es decir public class Animal implements Comparable<Animal>. Y luego tienes que implementar el compareTo(Animal other)método de la forma que más te guste.

@Override
public int compareTo(Animal other) {
    return Integer.compare(this.year_discovered, other.year_discovered);
}

Usando esta implementación de compareTo, los animales con un valor más alto year_discoveredse ordenarán más alto. Espero que se haga una idea de Comparabley compareTocon este ejemplo.

Necesitas:

• Agregar implements Comparable<Animal>a la declaración de clase; y
• Implemente un int compareTo( Animal a )método para realizar las comparaciones.

Me gusta esto:

public class Animal implements Comparable<Animal>{
    public String name;
    public int year_discovered; 
    public String population; 

    public Animal(String name, int year_discovered, String population){
        this.name = name;
        this.year_discovered = year_discovered;
        this.population = population;
    }

    public String toString(){
     String s = "Animal name: "+ name+"\nYear Discovered: "+year_discovered+"\nPopulation: "+population;
     return s;
    }

    @Override
    public int compareTo( final Animal o) {
        return Integer.compare(this.year_discovered, o.year_discovered);
    }
}

Mientras está en él, le sugiero que recuerde algunos datos clave sobre los métodos compareTo ()

1. CompareTo debe ser consistente con el método equals, por ejemplo, si dos objetos son iguales a través de equals (), compareTo () debe devolver cero; de lo contrario, si esos objetos se almacenan en SortedSet o SortedMap, no se comportarán correctamente.

2. CompareTo () debe lanzar NullPointerException si el objeto actual se compara con el objeto nulo en lugar de equals () que devuelve falso en tal escenario.

Leer más: http://javarevisited.blogspot.com/2011/11/how-to-override-compareto-method-in.html#ixzz4B4EMGha3

Implemente la Comparable<Animal>interfaz en su clase y proporcione la implementación del int compareTo(Animal other)método en su clase. Ver esta publicación

Necesitaría implementar la interfaz y definir el método compareTo (). Para obtener un buen tutorial, vaya a: enlace de punto de tutoriales o MyKongLink

Una posible alternativa del código fuente del Integer.comparemétodo que requiere API Version 19es:

public int compareTo(Animal other) { return Integer.valueOf(this.year_discovered).compareTo(other.year_discovered); }

Esta alternativa no requiere que la uses API version 19.

La clase Emp necesita implementar una interfaz Comaparable, por lo que debemos anular su método compateTo.

import java.util.ArrayList;
import java.util.Collections;


class Emp implements Comparable< Emp >{

    int empid;
    String name;

    Emp(int empid,String name){
         this.empid = empid;  
         this.name = name;

    }


    @Override
    public String toString(){
        return empid+" "+name;
    }

    @Override
    public int compareTo(Emp o) {

     if(this.empid==o.empid){
       return 0; 
     } 
     else if(this.empid < o.empid){
     return 1;
     }
     else{
       return -1;
     }
    }
}

public class JavaApplication1 {


    public static void main(String[] args) {

    ArrayList<Emp> a= new ArrayList<Emp>();

    a.add(new Emp(10,"Mahadev"));
      a.add(new Emp(50,"Ashish"));
      a.add(new Emp(40,"Amit"));
      Collections.sort(a);
      for(Emp id:a){
      System.out.println(id);
      }
    }

}

Aquí está el código para implementar una interfaz comparable a Java,

// adding implements comparable to class declaration
public class Animal implements Comparable<Animal>
{
    public String name;
    public int yearDiscovered;
    public String population;

    public Animal(String name, int yearDiscovered, String population)
    {
        this.name = name;
        this.yearDiscovered = yearDiscovered;
        this.population = population; 
    }

    public String toString()
    {
        String s = "Animal name : " + name + "\nYear Discovered : " + yearDiscovered + "\nPopulation: " + population;
        return s;
    }

    @Override
    public int compareTo(Animal other)  // compareTo method performs the comparisons 
    {
        return Integer.compare(this.year_discovered, other.year_discovered);
    }
}

Utilice un comparador ...

    public class AnimalAgeComparator implements Comparator<Animal> {

@Override
public int compare(Animal a1, Animal a2) {
  ...
}
}

Esto se puede hacer fácilmente implementando una clase pública que implemente Comparable. Esto le permitirá utilizar el método compareTo que se puede utilizar con cualquier otro objeto con el que desee comparar.

por ejemplo, puede implementarlo de esta manera:

public String compareTo(Animal oth) 
{
    return String.compare(this.population, oth.population);
}

Creo que esto podría resolver tu propósito.