Comment implémenter l'interface comparable Java?

Je ne sais pas comment implémenter une interface comparable dans ma classe abstraite. J'ai l'exemple de code suivant que j'utilise pour essayer de comprendre:

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

J'ai une classe de test qui créera des objets de type Animal, mais je souhaite avoir une interface comparable à l'intérieur de cette classe afin que les années de découverte plus anciennes soient plus élevées que faibles. Je n'ai aucune idée de la façon de procéder.

Vous avez juste à définir cela Animal implements Comparable<Animal>ie public class Animal implements Comparable<Animal>. Et puis vous devez implémenter la compareTo(Animal other)méthode comme vous l'aimez.

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

En utilisant cette implémentation de compareTo, les animaux avec un plus haut year_discoveredseront classés plus haut. J'espère que vous avez l'idée Comparableet compareToavec cet exemple.

Tu dois:

• Ajouter implements Comparable<Animal>à la déclaration de classe; et
• Implémentez une int compareTo( Animal a )méthode pour effectuer les comparaisons.

Comme ça:

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

Pendant que vous y êtes, je suggère de vous rappeler quelques faits clés sur les méthodes compareTo ()

1. CompareTo doit être cohérent avec la méthode equals, par exemple si deux objets sont égaux via equals (), compareTo () doit renvoyer zéro sinon si ces objets sont stockés dans SortedSet ou SortedMap, ils ne se comporteront pas correctement.

2. CompareTo () doit lancer NullPointerException si l'objet actuel est comparé à un objet nul par opposition à equals () qui retourne false dans un tel scénario.

En savoir plus: http://javarevisited.blogspot.com/2011/11/how-to-override-compareto-method-in.html#ixzz4B4EMGha3

Implémentez l' Comparable<Animal>interface dans votre classe et fournissez l'implémentation de la int compareTo(Animal other)méthode dans votre classe. Voir cet article

Vous devrez implémenter l'interface et définir la méthode compareTo (). Pour un bon tutoriel, allez à - Tutoriels point link ou MyKongLink

L'alternative possible au code source de la Integer.compareméthode qui nécessite API Version 19est:

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

Cette alternative ne vous oblige pas à l'utiliser API version 19.

La classe Emp doit implémenter l'interface Comaparable, nous devons donc remplacer sa méthode 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);
      }
    }

}

Voici le code pour implémenter une interface java comparable,

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

Utilisez un comparateur ...

    public class AnimalAgeComparator implements Comparator<Animal> {

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

Cette chose peut facilement être effectuée en implémentant une classe publique qui implémente Comparable. Cela vous permettra d'utiliser la méthode compareTo qui peut être utilisée avec tout autre objet auquel vous souhaitez comparer.

par exemple, vous pouvez l'implémenter de cette manière:

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

Je pense que cela pourrait résoudre votre objectif.