Menyortir Array di Jawa

1. Ikhtisar

Dalam tutorial ini, kita akan membahas metode umum untuk mengurutkan array dalam urutan naik dan turun.

Kita akan melihat penggunaan metode pengurutan kelas Array Java serta mengimplementasikan Pembanding kita sendiri untuk mengurutkan nilai array kita.

2. Definisi Objek

Sebelum kita mulai, mari kita dengan cepat mendefinisikan beberapa array yang akan kita sortir di sepanjang tutorial ini. Pertama, kita akan membuat array int dan array string:

int[] numbers = new int[] { -8, 7, 5, 9, 10, -2, 3 }; String[] strings = new String[] { "learning", "java", "with", "baeldung" };

Dan mari kita juga membuat array objek Employee di mana setiap karyawan memiliki id dan atribut name :

Employee john = new Employee(6, "John"); Employee mary = new Employee(3, "Mary"); Employee david = new Employee(4, "David"); Employee[] employees = new Employee[] { john, mary, david };

3. Menyortir dengan Urutan Naik

Metode util.Arays.sort Java memberi kita cara cepat dan sederhana untuk mengurutkan array primitif atau objek yang mengimplementasikan antarmuka Comparable dalam urutan menaik.

Saat mengurutkan primitif, metode Arrays.sort menggunakan implementasi Pivot Ganda dari Quicksort. Namun, saat menyortir objek, implementasi berulang MergeSort digunakan.

3.1. Primitif

Untuk mengurutkan array primitif dalam urutan menaik, kami meneruskan array kami ke metode sortir :

Arrays.sort(numbers); assertArrayEquals(new int[] { -8, -2, 3, 5, 7, 9, 10 }, numbers); 

3.2. Objek Yang Diimplementasikan Sebanding

Untuk objek yang mengimplementasikan antarmuka Comparable , seperti array primitif kita, kita juga dapat meneruskan array kita ke metode sortir :

Arrays.sort(strings); assertArrayEquals(new String[] { "baeldung", "java", "learning", "with" }, strings);

3.3. Objek yang Tidak Dapat Diimplementasikan Sebanding

Mengurutkan objek yang tidak mengimplementasikan Antarmuka yang Dapat Dibandingkan , seperti array Karyawan kami , mengharuskan kami menentukan pembanding kami sendiri.

Kita bisa melakukan ini dengan sangat mudah di Java 8 dengan menentukan properti tempat kita ingin membandingkan objek Employee di dalam Comparator kita :

Arrays.sort(employees, Comparator.comparing(Employee::getName)); assertArrayEquals(new Employee[] { david, john, mary }, employees);

Dalam hal ini, kami telah menetapkan bahwa kami ingin memesan karyawan kami berdasarkan atribut nama mereka .

Kita juga dapat mengurutkan objek kita pada lebih dari satu atribut dengan merangkai perbandingan kita menggunakan metode Comparator's thenComparing :

Arrays.sort(employees, Comparator.comparing(Employee::getName).thenComparing(Employee::getId));

4. Menyortir dalam Urutan Menurun

4.1. Primitif

Mengurutkan array primitif dalam urutan menurun tidak sesederhana mengurutkan dalam urutan menaik karena Java tidak mendukung penggunaan Pembanding pada tipe primitif. Untuk mengatasi kekurangan ini kami memiliki beberapa opsi.

Pertama, kita bisa mengurutkan array kita dalam urutan menaik dan kemudian melakukan pembalikan array di tempat.

Kedua, dapat mengubah array kita menjadi sebuah daftar, menggunakan metode Guava's Lists.reverse () dan kemudian mengubah daftar kita kembali menjadi sebuah array.

Akhirnya, kita bisa mengubah array kita menjadi Stream dan kemudian memetakannya kembali ke array int . Ini memiliki keuntungan bagus menjadi one-liner dan hanya menggunakan inti Java:

numbers = IntStream.of(numbers).boxed().sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray(); assertArrayEquals(new int[] { 10, 9, 7, 5, 3, -2, -8 }, numbers);

Alasan karya ini adalah bahwa kotak bergantian setiap int menjadi Integer , yang tidak menerapkan Comparator.

4.2. Objek Yang Diimplementasikan Sebanding

Mengurutkan larik objek yang mengimplementasikan antarmuka Comparable dalam urutan menurun cukup sederhana. Yang perlu kita lakukan adalah memberikan Comparator sebagai parameter kedua dari metode sortir kita .

Di Java 8 kita bisa menggunakan Comparator.reverseOrder () untuk menunjukkan bahwa kita ingin array kita diurutkan dalam urutan menurun:

Arrays.sort(strings, Comparator.reverseOrder()); assertArrayEquals(new String[] { "with", "learning", "java", "baeldung" }, strings);

4.3. Objek yang Tidak Dapat Diimplementasikan Sebanding

Demikian pula untuk mengurutkan objek yang mengimplementasikan sebanding, kita dapat membalik urutan Pembanding kustom kita dengan menambahkan reversed () di akhir definisi perbandingan kita:

Arrays.sort(employees, Comparator.comparing(Employee::getName).reversed()); assertArrayEquals(new Employee[] { mary, john, david }, employees);

5. Kesimpulan

Pada artikel ini, kita membahas cara mengurutkan array primitif dan objek dalam urutan naik dan turun menggunakan metode Arrays.sort .

Seperti biasa, kode sumber dari artikel ini dapat ditemukan di Github.