Come implementare l'interfaccia comparabile Java?

Non sono sicuro di come implementare un'interfaccia comparabile nella mia classe astratta. Ho il seguente codice di esempio che sto usando per provare a capirlo:

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;
    }
}

Ho una classe di prova che creerà oggetti di tipo Animale, tuttavia voglio avere un'interfaccia comparabile all'interno di questa classe in modo che gli anni di scoperta più vecchi siano più alti che bassi. Non ho idea di come procedere però.

Devi solo definire che Animal implements Comparable<Animal>ie public class Animal implements Comparable<Animal>. E poi devi implementare il compareTo(Animal other)metodo nel modo che preferisci.

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

Usando questa implementazione di compareTo, gli animali con un valore più alto year_discoveredverranno ordinati più in alto. Spero che tu abbia l'idea di Comparablee compareTocon questo esempio.

Devi:

• Aggiungi implements Comparable<Animal>alla dichiarazione di classe; e
• Implementa un int compareTo( Animal a )metodo per eseguire i confronti.

Come questo:

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);
    }
}

Già che ci sei, ti suggerisco di ricordare alcuni fatti chiave sui metodi compareTo ()

1. CompareTo deve essere coerente con il metodo equals, ad esempio se due oggetti sono uguali tramite equals (), compareTo () deve restituire zero altrimenti se quegli oggetti sono memorizzati in SortedSet o SortedMap non si comporteranno correttamente.

2. CompareTo () deve lanciare NullPointerException se l'oggetto corrente viene confrontato con un oggetto nullo invece di equals () che restituisce false in tale scenario.

Per saperne di più: http://javarevisited.blogspot.com/2011/11/how-to-override-compareto-method-in.html#ixzz4B4EMGha3

Implementa l' Comparable<Animal>interfaccia nella tua classe e fornisci l'implementazione del int compareTo(Animal other)metodo nella tua classe. Vedi questo post

Dovresti implementare l'interfaccia e definire il metodo compareTo (). Per un buon tutorial vai a - Collegamento punto tutorial o MyKongLink

Possibile alternativa dal codice sorgente del Integer.comparemetodo che richiede API Version 19è:

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

Questa alternativa non richiede l'utilizzo API version 19.

La classe Emp deve implementare l'interfaccia Comaparable, quindi è necessario eseguire l'override del suo metodo 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);
      }
    }

}

Ecco il codice per implementare un'interfaccia comparabile 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);
    }
}

Usa un comparatore ...

    public class AnimalAgeComparator implements Comparator<Animal> {

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

Questa operazione può essere eseguita facilmente implementando una classe pubblica che implementa Comparable. Ciò ti consentirà di utilizzare il metodo compareTo che può essere utilizzato con qualsiasi altro oggetto con cui desideri confrontare.

ad esempio puoi implementarlo in questo modo:

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

Penso che questo potrebbe risolvere il tuo scopo.