Mengapa kelas Java menerapkan sebanding?

Mengapa Java Comparabledigunakan? Mengapa seseorang menerapkan Comparabledi kelas? Apa contoh kehidupan nyata di mana Anda perlu menerapkan sebanding?

Berikut adalah contoh kehidupan nyata. Perhatikan bahwa Stringjuga mengimplementasikan Comparable.

class Author implements Comparable<Author>{
    String firstName;
    String lastName;

    @Override
    public int compareTo(Author other){
        // compareTo should return < 0 if this is supposed to be
        // less than other, > 0 if this is supposed to be greater than 
        // other and 0 if they are supposed to be equal
        int last = this.lastName.compareTo(other.lastName);
        return last == 0 ? this.firstName.compareTo(other.firstName) : last;
    }
}

kemudian..

/**
 * List the authors. Sort them by name so it will look good.
 */
public List<Author> listAuthors(){
    List<Author> authors = readAuthorsFromFileOrSomething();
    Collections.sort(authors);
    return authors;
}

/**
 * List unique authors. Sort them by name so it will look good.
 */
public SortedSet<Author> listUniqueAuthors(){
    List<Author> authors = readAuthorsFromFileOrSomething();
    return new TreeSet<Author>(authors);
}

Comparable mendefinisikan pemesanan alami. Artinya, Anda mendefinisikannya ketika satu objek harus dianggap "kurang dari" atau "lebih besar dari".

Misalkan Anda memiliki banyak bilangan bulat dan Anda ingin mengurutkannya. Itu cukup mudah, taruh saja dalam koleksi yang disortir, bukan?

TreeSet<Integer> m = new TreeSet<Integer>(); 
m.add(1);
m.add(3);
m.add(2);
for (Integer i : m)
... // values will be sorted

Tapi sekarang misalkan saya memiliki beberapa objek khusus, di mana pengurutan masuk akal bagi saya, tetapi tidak ditentukan. Katakanlah, saya memiliki data yang mewakili kabupaten berdasarkan kode pos dengan kepadatan penduduk, dan saya ingin mengurutkannya berdasarkan kepadatan:

public class District {
  String zipcode; 
  Double populationDensity;
}

Sekarang cara termudah untuk mengurutkannya adalah dengan mendefinisikannya dengan pengurutan natural dengan mengimplementasikan Comparable, yang berarti ada cara standar untuk mendefinisikan objek-objek ini untuk diurutkan .:

public class District implements Comparable<District>{
  String zipcode; 
  Double populationDensity;
  public int compareTo(District other)
  {
    return populationDensity.compareTo(other.populationDensity);
  }
}

Perhatikan bahwa Anda dapat melakukan hal yang setara dengan menentukan pembanding. Perbedaannya adalah bahwa pembanding mendefinisikan logika pengurutan di luar objek . Mungkin dalam proses terpisah saya perlu memesan objek yang sama dengan kode pos - dalam hal ini pemesanan belum tentu merupakan properti objek, atau berbeda dari pengurutan objek secara alami. Anda dapat menggunakan pembanding eksternal untuk menentukan pengurutan kustom pada bilangan bulat, misalnya dengan mengurutkan berdasarkan nilai abjad.

Pada dasarnya logika pemesanan harus ada di suatu tempat. Itu bisa jadi -

• di objek itu sendiri, jika itu secara alami sebanding (meluas bilangan bulat -eg yang sebanding)

• disediakan dalam komparator eksternal, seperti pada contoh di atas.

Dikutip dari javadoc;

Antarmuka ini memberlakukan pengurutan total pada objek dari setiap kelas yang mengimplementasikannya. Pengurutan ini disebut sebagai pengurutan alami kelas, dan metode bandingkan kelas disebut sebagai metode perbandingan alami.

Daftar (dan larik) objek yang mengimplementasikan antarmuka ini dapat diurutkan secara otomatis berdasarkan Collections.sort (dan Arrays.sort). Objek yang mengimplementasikan antarmuka ini dapat digunakan sebagai kunci dalam peta yang diurutkan atau sebagai elemen dalam kumpulan yang diurutkan, tanpa perlu menentukan pembanding.

Sunting: ..dan buat bagian penting ditebalkan.

Fakta bahwa sebuah kelas mengimplementasikan Comparableberarti Anda dapat mengambil dua objek dari kelas itu dan membandingkannya. Beberapa kelas, seperti koleksi tertentu (fungsi sortir dalam koleksi) yang menjaga agar objek tetap teratur bergantung padanya agar dapat dibandingkan (untuk mengurutkan Anda perlu mengetahui objek mana yang "terbesar" dan seterusnya).

Sebagian besar contoh di atas menunjukkan cara menggunakan kembali objek pembanding yang ada dalam fungsi bandingkanTo. Jika Anda ingin mengimplementasikan CompareTo Anda sendiri saat Anda ingin membandingkan dua objek dari kelas yang sama, katakanlah objek AirlineTicket yang ingin Anda urutkan berdasarkan harga (lebih sedikit adalah peringkat pertama), diikuti dengan jumlah persinggahan (sekali lagi, less is peringkat pertama), Anda akan melakukan hal berikut:

class AirlineTicket implements Comparable<Cost>
{
    public double cost;
    public int stopovers;
    public AirlineTicket(double cost, int stopovers)
    {
        this.cost = cost; this.stopovers = stopovers ;
    }

    public int compareTo(Cost o)
    {
        if(this.cost != o.cost)
          return Double.compare(this.cost, o.cost); //sorting in ascending order. 
        if(this.stopovers != o.stopovers)
          return this.stopovers - o.stopovers; //again, ascending but swap the two if you want descending
        return 0;            
    }
}

Cara mudah untuk mengimplementasikan beberapa perbandingan bidang adalah dengan Guava's ComparisonChain - Anda bisa mengatakannya

   public int compareTo(Foo that) {
     return ComparisonChain.start()
         .compare(lastName, that.lastName)
         .compare(firstName, that.firstName)
         .compare(zipCode, that.zipCode)
         .result();
   }

dari pada

  public int compareTo(Person other) {
    int cmp = lastName.compareTo(other.lastName);
    if (cmp != 0) {
      return cmp;
    }
    cmp = firstName.compareTo(other.firstName);
    if (cmp != 0) {
      return cmp;
    }
    return Integer.compare(zipCode, other.zipCode);
  }
}

Comparable digunakan untuk membandingkan instance kelas Anda. Kita dapat membandingkan instance dari banyak cara, itulah sebabnya kita perlu mengimplementasikan metode compareTountuk mengetahui bagaimana (atribut) kita ingin membandingkan instance.

Dog kelas:

package test;
import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        Dog d1 = new Dog("brutus");
        Dog d2 = new Dog("medor");
        Dog d3 = new Dog("ara");
        Dog[] dogs = new Dog[3];
        dogs[0] = d1;
        dogs[1] = d2;
        dogs[2] = d3;

        for (int i = 0; i < 3; i++) {
            System.out.println(dogs[i].getName());
        }
        /**
         * Output:
         * brutus
         * medor
         * ara
         */

        Arrays.sort(dogs, Dog.NameComparator);
        for (int i = 0; i < 3; i++) {
            System.out.println(dogs[i].getName());
        }
        /**
         * Output:
         * ara
         * medor
         * brutus
         */

    }
}

Main kelas:

package test;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        Dog d1 = new Dog("brutus");
        Dog d2 = new Dog("medor");
        Dog d3 = new Dog("ara");
        Dog[] dogs = new Dog[3];
        dogs[0] = d1;
        dogs[1] = d2;
        dogs[2] = d3;

        for (int i = 0; i < 3; i++) {
            System.out.println(dogs[i].getName());
        }
        /**
         * Output:
         * brutus
         * medor
         * ara
         */

        Arrays.sort(dogs, Dog.NameComparator);
        for (int i = 0; i < 3; i++) {
            System.out.println(dogs[i].getName());
        }
        /**
         * Output:
         * ara
         * medor
         * brutus
         */

    }
}

Berikut adalah contoh bagus bagaimana menggunakan yang sebanding di Java:

http://www.onjava.com/pub/a/onjava/2003/03/12/java_comp.html?page=2

Misalnya ketika Anda ingin memiliki koleksi atau peta yang diurutkan

Saat Anda mengimplementasikan Comparableantarmuka, Anda perlu mengimplementasikan metode compareTo(). Anda memerlukannya untuk membandingkan objek, untuk menggunakan, misalnya, metode pengurutan ArrayListkelas. Anda memerlukan cara untuk membandingkan objek Anda agar dapat mengurutkannya. Jadi, Anda memerlukan compareTo()metode khusus di kelas Anda sehingga Anda dapat menggunakannya dengan ArrayListmetode sortir. The compareTo()kembali metode -1,0,1.

Saya baru saja membaca bab yang sesuai di Java Head 2.0, saya masih belajar.

Oke, tapi mengapa tidak mendefinisikan compareTo()metode saja tanpa mengimplementasikan antarmuka yang sebanding. Misalnya kelas yang Cityditentukan oleh namedan temperaturedan

public int compareTo(City theOther)
{
    if (this.temperature < theOther.temperature)
        return -1;
    else if (this.temperature > theOther.temperature)
        return 1;
    else
        return 0;
}