Bagaimanakah Comparator berfungsi di Java?

pengenalan

Kadang-kadang apabila bekerja pada projek keperluan timbul untuk mengisih beberapa jenis koleksi objek, untuk ini anda mungkin berfikir bahawa ia adalah perlu untuk melaksanakan algoritma pengisihan kami sendiri, tetapi ini agak tidak perlu, walaupun tidak menyakitkan untuk mengetahui bagaimana mereka bekerja. Sebagai contoh, jika anda mempunyai tatasusunan integer, anda boleh menggunakan kaedah Arrays.sort() yang menerima tatasusunan primitif dan mengisihnya dalam tertib menaik, mengambil kesempatan daripada fakta bahawa ia tidak perlu untuk memberikan hasil kepada pembolehubah baharu, kerana kaedah tersebut mengubah suai tatasusunan asal.

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Ini juga terpakai apabila anda mempunyai koleksi objek tersuai, contohnya, rekod jenis Filem, tetapi jika kita melihat kaedah Arrays.sort() ia tidak menerima tatasusunan objek jenis ini, jadi ia mesti gunakan kaedah sort() yang menerima sebagai parameter objek jenis T dan objek jenis Comparator yang merupakan antara muka berfungsi. Antara muka ini sangat penting, kerana banyak kaedah lain dalam Java menggunakannya untuk membandingkan objek dengan cara tersuai. Contohnya, kaedah Collections.sort() atau kaedah sort() bagi objek List, malah Streams menerima Comparator untuk mengisih elemen.

Apa itu Comparator?

Antara muka berfungsi Pembanding (berfungsi ia boleh ditulis sebagai ungkapan lambda) ialah antara muka yang membolehkan anda membandingkan dua objek jenis T, jadi ia digunakan untuk membandingkan integer, rentetan, tersuai objek, dsb Antara muka mempunyai beberapa kaedah statik dan lalai, tetapi yang penting ialah kaedah compare(), iaitu kaedah yang mesti dilaksanakan untuk membandingkan dua objek. compare() menerima dua objek jenis T dan mengembalikan integer. Tandatangan kaedah adalah seperti berikut:

int compare(T o1, T o2);

Kaedah ini mengembalikan nombor negatif jika o1 kurang daripada o2, sifar jika sama dan nombor positif jika o1 lebih besar daripada o2, biasanya ia mengembalikan -1, 0 atau 1 masing-masing.

Apakah yang dimaksudkan bahawa satu objek kurang daripada, sama dengan, atau lebih besar daripada yang lain?

Mari kita analisa apa yang dipulangkan oleh kaedah compare() kerana susunan objek bergantung pada perkara ini. Adalah penting untuk mempertimbangkan bahawa maksud kaedah yang dikembalikan adalah relatif, iaitu, jika anda ingin memesan secara menaik atau menurun. Ia bergantung kepada keadaan dan bagaimana ia dilaksanakan. Mari kita pertimbangkan rekod berikut untuk setiap contoh:

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

• Jika hujah pertama kurang daripada yang kedua, nombor negatif dikembalikan. Contohnya, untuk mengisih filem mengikut tahun keluaran, -1 boleh dikembalikan apabila filem a lebih kecil daripada filem b:

int compare(T o1, T o2);

• Jika hujah pertama lebih besar daripada yang kedua, nombor positif dikembalikan. Contohnya, untuk mengisih filem mengikut belanjawan, 1 boleh dikembalikan apabila filem a lebih besar daripada filem b:

public record Movie(
        String name,
        List<String> actors,
        int budget,
        int year
) {
}

• Jika hujah pertama sama dengan hujah kedua, sifar dikembalikan. Contohnya, untuk mengisih filem mengikut bilangan pelakon, 0 boleh dikembalikan apabila filem a bersamaan dengan filem b:

// a < b -> -1
a.year() < b.year() -> -1

Menggunakan Pembanding

Andaikan kita mempunyai filem berikut di dalam objek jenis List:

// a > b -> 1
a.budget() > b.budget() -> 1

Jika anda ingin memesan filem mengikut tahun keluaran dalam tertib menaik, anda boleh mencipta objek jenis Comparator dan mengatasi kaedah compare() dan kemudian hantar objek ini kepada kaedah sort() senarai:

// a == b -> 0
a.actors().size() == b.actors().size() -> 0

Ia juga boleh dilaksanakan sebagai kelas tanpa nama dalam kaedah sort():

Movie movie1 = new Movie("The Godfather", Arrays.asList("Marlon Brando", "Al Pacino"), 6000000, 1972);
Movie movie2 = new Movie("The Godfather: Part II", Arrays.asList("Al Pacino", "Robert De Niro"), 13000000, 1974);
Movie movie3 = new Movie("The Shawshank Redemption", Arrays.asList("Tim Robbins", "Morgan Freeman"), 25000000, 1994);
Movie movie4 = new Movie("The Dark Knight", Arrays.asList("Christian Bale", "Heath Ledger"), 185000000, 2008);

List<Movie> movies = Arrays.asList(movie1, movie2, movie3, movie4);

Atau lebih ringkas menggunakan ungkapan lambda secara langsung dalam kaedah sort():

Comparator<Movie> comparatorByYear = new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
};

movies.sort(comparatorByYear);

Mana-mana pelaksanaan ini akan mengisih senarai menaik mengikut tahun keluaran. Jika anda ingin mengisih dalam tertib menurun, anda boleh menukar susunan hujah dalam ungkapan lambda atau menambah tanda negatif dalam penolakan:

movies.sort(new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
});

Beberapa contoh lain tentang cara senarai objek tersuai boleh diisih ialah:

• Susun filem mengikut bilangan pelakon dalam tertib menaik (kurang pelakon kepada lebih ramai pelakon):

movies.sort((p1, p2) -> p1.year() - p2.year());

• Isih filem mengikut belanjawan dalam tertib menurun (belanjawan tertinggi kepada belanjawan terendah):

movies.sort((p1, p2) -> p2.year() - p1.year());
// o
movies.sort((p1, p2) -> - (p1.year() - p2.year()));

• Isih filem mengikut nama dalam tertib menaik:

movies.sort((p1, p2) -> p1.actors().size() - p2.actors().size());

Antara contoh lain, kita boleh mempunyai kes di mana perlu mengisih senarai integer dalam tertib menurun,

movies.sort((p1, p2) -> p2.budget() - p1.budget());
// o 
movies.sort((p1, p2) -> - (p1.budget() - p2.budget()));

Untuk melakukan ini, anda juga boleh menggunakan kaedah statik Comparator.reverseOrder() yang mengembalikan komparator yang menyusun elemen dalam tertib menurun dan Comparator.naturalOrder() yang menyusun elemen dalam tertib menaik.

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Gunakan Integer.compare()

Dalam Java sudah ada kaedah yang membolehkan kami melakukan perbandingan jenis ini dengan cara yang cekap, contohnya Integer.compare() yang membandingkan dua integer dan mengembalikan nombor negatif jika argumen pertama kurang daripada kedua, sifar jika sama dan nombor positif jika hujah pertama lebih besar daripada yang kedua. Jika kita menganalisis cara kaedah ini berfungsi, kita dapat melihat bahawa ia adalah serupa dengan apa yang telah dijelaskan di atas dan mengembalikan dengan tepat apa yang diperlukan oleh kaedah compare() antara muka Comparator. Pelaksanaan Integer.compare() adalah seperti berikut:

int compare(T o1, T o2);

Jadi, jika anda ingin mengisih filem mengikut tahun keluaran dalam tertib menaik, anda boleh menggunakan Integer.compare():

public record Movie(
        String name,
        List<String> actors,
        int budget,
        int year
) {
}

Menggunakan kaedah rujukan

Kadangkala kaedah rujukan boleh digunakan untuk melakukan perbandingan secara berbeza daripada sebelumnya, sebagai contoh, untuk mengisih senarai integer dalam tertib menaik:

// a < b -> -1
a.year() < b.year() -> -1

Integer bukan satu-satunya kelas yang mempunyai kaedah compareTo(), contohnya String mempunyai kaedah compareTo() yang membandingkan dua rentetan secara leksikografik, jadi ia boleh digunakan untuk mengisih senarai rentetan, atau bahkan menggunakan CharSequence dengannya kaedah compare() (secara teknikalnya mewakili urutan aksara).

// a > b -> 1
a.budget() > b.budget() -> 1

Berbalik kepada contoh filem, jika anda ingin mengisih filem mengikut tahun keluaran dalam tertib menaik, anda boleh menggunakan kaedah comparingInt() sebagai kaedah rujukan:

// a == b -> 0
a.actors().size() == b.actors().size() -> 0

Atau untuk membandingkan mengikut atribut jenis String, dalam kes ini nama filem:

Movie movie1 = new Movie("The Godfather", Arrays.asList("Marlon Brando", "Al Pacino"), 6000000, 1972);
Movie movie2 = new Movie("The Godfather: Part II", Arrays.asList("Al Pacino", "Robert De Niro"), 13000000, 1974);
Movie movie3 = new Movie("The Shawshank Redemption", Arrays.asList("Tim Robbins", "Morgan Freeman"), 25000000, 1994);
Movie movie4 = new Movie("The Dark Knight", Arrays.asList("Christian Bale", "Heath Ledger"), 185000000, 2008);

List<Movie> movies = Arrays.asList(movie1, movie2, movie3, movie4);

Isih mengikut berbilang atribut

Kadangkala anda mungkin perlu mengisih senarai objek mengikut berbilang atribut, contohnya, jika anda ingin mengisih filem mengikut tahun keluaran dalam tertib menaik dan mengikut belanjawan dalam tertib menurun, anda boleh menggunakan kaedah thenComparing() yang menerima seorang Pembanding dan bertanggungjawab untuk memesan mengikut pelbagai atribut. Contohnya, jika terdapat dua filem a dan b, dengan tahun keluaran yang sama, ia akan dipesan mengikut bajet.

Comparator<Movie> comparatorByYear = new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
};

movies.sort(comparatorByYear);

Kesimpulan

Pembanding berguna dalam Java pada banyak masa, kerana ia membenarkan anda membandingkan objek dengan cara yang diperibadikan, dan bukan itu sahaja, tetapi ia juga boleh digunakan dalam banyak kaedah pengumpulan Java, malah mempunyai lebih daripada satu pembanding untuk diisih dengan cara yang berbeza. Sama ada cara, anda boleh merujuk dokumentasi Comparator dalam IDE atau dalam dokumentasi Java rasmi untuk melihat kaedah yang boleh digunakan dan cara ia boleh dilaksanakan.

Atas ialah kandungan terperinci Bagaimanakah Comparator berfungsi di Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!