Jak zaimplementować porównywalny interfejs Java?

Nie jestem pewien, jak zaimplementować porównywalny interfejs do mojej klasy abstrakcyjnej. Mam następujący przykładowy kod, którego używam, aby go obejść:

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

Mam klasę testową, która utworzy obiekty typu Animal, jednak chcę mieć porównywalny interfejs wewnątrz tej klasy, aby starsze lata odkryć były wyższe niż niskie. Nie mam jednak pojęcia, jak się do tego zabrać.

Musisz tylko to zdefiniować Animal implements Comparable<Animal>tj public class Animal implements Comparable<Animal>. A potem musisz zaimplementować compareTo(Animal other)metodę tak, jak lubisz.

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

Korzystając z tej implementacji compareTo, zwierzęta z wyższą pozycją year_discoveredzostaną zamówione wyżej. Mam nadzieję, że masz pomysł Comparablei compareToz tego przykładu.

Musisz:

• Dodaj implements Comparable<Animal>do deklaracji klasy; i
• Zaimplementuj int compareTo( Animal a )metodę wykonywania porównań.

Lubię to:

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

Skoro już to robisz, proponuję przypomnieć sobie kilka kluczowych faktów na temat metod compareTo ()

1. CompareTo musi być spójny z metodą equals, np. Jeśli dwa obiekty są równe za pomocą equals (), funkcja CompareTo () musi zwracać zero, w przeciwnym razie, jeśli te obiekty są przechowywane w SortedSet lub SortedMap, nie będą się zachowywać poprawnie.

2. CompareTo () musi zgłosić wyjątek NullPointerException, jeśli bieżący obiekt zostanie porównany z obiektem null, w przeciwieństwie do equals (), które w takim scenariuszu zwracają false.

Czytaj więcej: http://javarevisited.blogspot.com/2011/11/how-to-override-compareto-method-in.html#ixzz4B4EMGha3

Zaimplementuj Comparable<Animal>interfejs w swojej klasie i zapewnij implementację int compareTo(Animal other)metody w swojej klasie. Zobacz ten post

Musisz zaimplementować interfejs i zdefiniować metodę compareTo (). Aby zapoznać się z dobrym samouczkiem, przejdź do - Link do samouczka lub MyKongLink

Możliwa alternatywa dla kodu źródłowego Integer.comparemetody, która wymaga API Version 19:

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

Ta alternatywa nie wymaga użycia API version 19.

Klasa Emp musi zaimplementować interfejs Comaparable, więc musimy zastąpić jej metodę 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);
      }
    }

}

Oto kod implementujący porównywalny interfejs 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);
    }
}

Użyj komparatora ...

    public class AnimalAgeComparator implements Comparator<Animal> {

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

Można to łatwo zrobić, implementując publiczną klasę, która implementuje Comparable. Umożliwi to użycie metody compareTo, której można użyć z dowolnym innym obiektem, z którym chcesz porównać.

na przykład możesz to zaimplementować w ten sposób:

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

Myślę, że to może rozwiązać twój cel.