Jenis Koleksi Java ()

Salah satu fungsi paling umum yang kami butuhkan sebagai developer yang berurusan dengan data adalah menyortir--dengan dapat mengurutkan data, kami dapat mengoptimalkan algoritme agar berjalan lebih cepat, dan menemukan data yang diperlukan dalam waktu singkat. akan mengambil untuk sebaliknya. Dalam pelajaran hari ini, kita akan membahas tentang Java Collections sort(). Sebagai eksperimen pikiran cepat: bayangkan Anda sedang mencari nama melalui daftar nama universitas. Mungkin ada puluhan ribu siswa di sekolah ini. Jika daftar nama yang Anda berikan tidak dalam urutan abjad, Anda perlu membolak-balik setiap halaman dan melihat dengan sangat hati-hati untuk memastikan Anda tidak melewatkan satu nama pun, sampai akhirnya Anda menemukan nama yang Anda cari. Di sisi lain, jika daftar itu disusun berdasarkan abjad, Anda tidak hanya harus kurang teliti dalam pencarian Anda, tetapi Anda dapat dengan mudah melompat ke bagian dalam daftar dengan huruf pertama yang sama, dan terus melompati halaman dengan lompatan besar sampai Anda menemukan orang yang Anda cari. Semakin banyak data yang Anda gunakan, semakin penting Anda menggunakannya seefektif dan seefisien mungkin. Pada artikel ini, kita akan membahas cara mengurutkan implementasi Daftar apa pun di Java (termasuk ArrayList) menggunakan metode pengurutan Koleksi.

Cara Mengurutkan ArrayList di Java menggunakan metode pengurutan Koleksi Java

Mari kita bicara tentang metode Java Collections.sort. Paket java.util berisi banyak utilitas dan paket berguna yang sering digunakan oleh pengembang, termasuk ArrayList. Misalkan Anda memiliki program sederhana berikut:

import java.util.*;
import java.io.*;
class Main{
     public static void main(String[] args){
          List<String> colors = new ArrayList<String>();
          colors.add("Red    ");
          colors.add("Orange");
          colors.add("Green");
          colors.add("Blue");
    }
}

Anda ingin dapat mencetak daftar warna, tetapi dalam urutan abjad. Bagaimana Anda bisa melakukan ini? Menggunakan java.util.Collections, menyortir semudah one-liner:

Collections.sort(colors);

Ta-da! Daftar warna Anda sekarang telah disortir di tempat. Jika Anda mencetak daftar, seperti:

System.out.println(colors);

Maka Anda akan mendapatkan output berikut:

[Blue, Green, Orange, Red]

Betapa mudahnya itu ?! Akan sama mudahnya menggunakan Collections.sort() untuk mengurutkan daftar Integer, Float, atau tipe data sederhana lainnya dalam urutan menaik. Tetapi bagaimana jika Anda ingin mengurutkan dalam urutan menurun? Pasti ada kasus di mana ini masuk akal - bayangkan Anda memiliki daftar nilai ujian untuk kelas tertentu, dan Anda ingin mencari tahu siapa siswa dengan nilai tertinggi. Akan jauh lebih masuk akal untuk mengurutkan daftar dalam urutan menurun (skor tertinggi terlebih dahulu), sehingga jawaban yang Anda cari berada tepat di atas. Untungnya, Collections.sort() ditimpa dengan parameter ke-2 opsional, yang memungkinkan Anda melakukan hal ini:

sort(List l, Comparator c)

Tapi apa itu pembanding? Nah, komparator hanyalah sebuah fungsi yang membandingkan dua input dan mengembalikan angka yang mewakili input mana yang lebih dulu. Jika Anda mengurutkan ArrayList dari tipe data primitif, maka Java Collections sudah memberi Anda komparator ReverseOrder() . Itu bisa disebut seperti ini:

Collections.sort(colors, Collections.reverseOrder());

Sekarang, warna telah disortir terbalik di tempat sehingga jika Anda mencetaknya, Anda akan mendapatkan hasil sebagai berikut:

[Red, Orange, Green, Blue]

Cara menggunakan Collections untuk mengurutkan tipe data non-primitif di Java

Sejauh ini, Anda telah melihat bahwa mengurutkan ArrayLists dari string atau int di Java menggunakan metode Collections.sort() semudah satu baris kode. Namun seringkali, ArrayLists Anda akan menyimpan tipe data non-primitif. Saat Anda bekerja dengan data yang memiliki atribut yang lebih kompleks, Anda akan ingin menulis kelas untuk mewakili objek ini dan bagaimana mereka akan dibandingkan satu sama lain menggunakan atributnya. Untuk mempelajari contohnya, mari kita lihat kembali contoh mengurutkan daftar warna, tetapi kali ini, daripada mengurutkan String, kita akan menyortir objek Warna. Kelas Warna dasar kita mungkin terlihat seperti ini:

public class Color{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(String name, int red, int green, int blue){
   	this.name = name;
    	this.r = red;
   	this.g = green;
   	this.b = blue;
	}
}

Untuk membuat kelas Warna kita kompatibel dengan Collections.sort(), sehingga Koleksi dapat memahami cara membandingkan dan mengurutkan objek Warna, kita perlu membuat dua modifikasi kecil:

1. jadikan Color sebagai objek Sebanding (tambahkan implements Sebanding<Objek>)
2. timpa metode bandingkanTo di kelas (timpa public int bandingkanTo(Object o))

Dengan modifikasi ini, kelas kita sekarang terlihat seperti ini:

public class Color implements Comparable<Object>{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(int red int green, int blue, String name){
    	this.r = red;
   	this.g = green;
   	this.b = blue;
   	this.name = name;
	}

	@Override
	public int compareTo(Object o) {
    	Color c = (Color) o;
    	return this.name.compareTo(c.name);
	}
}

Perhatikan bahwa metode bandingkanTo dari Color hanya memanggil metode bandingkanTo dari String; penyortiran akan dilakukan dalam urutan abjad. Jika kita ingin mengurutkan berdasarkan nilai merah dalam urutan menaik, misalnya, kita dapat mengganti pernyataan return dengan return this.r - cr; (jika kita ingin mengurutkan berdasarkan nilai hijau dalam urutan menurun, itu akan menjadi return cg - this.g;). Sekarang, jika kita menelepon

Collections.sort(colors);

pada ArrayList of Colors daripada hanya Strings, ini akan berhasil karena Collections memahami cara membandingkan objek Color. Jika Anda tidak ingin membuat objek Anda mengimplementasikan Sebanding<Objek>, Anda bisa menulis komparator untuk kelas Anda, dan meneruskannya ke metode Collections.sort() 2-parameter. Komparator menggantikan metode public int compare(Object one, Object two), dan metode Collections.sort() menggunakan ini untuk membandingkan objek saat menyortir. Contoh pembanding SortByName dan SortByRed diimplementasikan di bawah ini:

class SortByName implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.name.compareTo(b.name);
	}
}

class SortByRGB implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.r - b.r;
	}
}

Dengan ini, Anda sekarang dapat menelepon

Collections.sort(colors, new SortByName());

tanpa kelas Color benar-benar mengimplementasikan Sebanding, dan itu akan tetap berfungsi. Terkadang, Anda akan melihat ini dilakukan secara in-line, menggunakan fungsi lambda. Fungsi lambda pada dasarnya adalah fungsi tanpa nama yang dapat Anda tentukan di dalam baris kode, yang memanggilnya. Mereka berguna ketika Anda hanya perlu memanggil fungsi untuk satu contoh tertentu dan tidak ingin mendefinisikan seluruh fungsi terpisah di tempat lain. Komparator SortByName dapat didefinisikan secara in-line, menggunakan fungsi lambda, seperti ini:

Collections.sort(colors, (a, b)-> {
          return a.name.compareTo(b.name)});

Seperti yang mungkin sudah Anda duga, (a,b) mewakili parameter fungsi lambda (dua objek yang akan dibandingkan). -> menandakan bahwa yang berikut adalah definisi fungsi lambda. Itu saja! Anda sekarang telah melihat metode paling populer untuk mengurutkan ArrayLists di Java menggunakan paket Collections.