Isih Koleksi Java()

Salah satu fungsi paling biasa yang kami perlukan sebagai pembangun yang berurusan dengan data ialah pengisihan--dengan dapat mengisih data kami, kami boleh mengoptimumkan algoritma kami untuk berjalan dengan lebih pantas dan mencari data yang diperlukannya dalam sebahagian kecil daripada masa ia akan mengambil sebaliknya. Dalam pelajaran hari ini, kita akan bercakap tentang Java Collections sort(). Sebagai percubaan pemikiran pantas: bayangkan anda sedang mencari nama melalui senarai universiti. Mungkin ada puluhan ribu pelajar di sekolah ini. Jika senarai yang diberikan kepada anda tidak mengikut susunan abjad, anda perlu menyelak setiap halaman dan melihat dengan teliti untuk memastikan anda tidak melangkau satu nama di mana-mana, sehingga anda akhirnya menemui nama yang anda cari. Sebaliknya, jika senarai mengikut abjad, bukan sahaja anda perlu kurang teliti dalam carian anda, tetapi anda boleh dengan mudah melompat ke bahagian dalam senarai dengan huruf pertama yang sama, dan terus melompat ke sekeliling halaman dalam lompatan besar sehingga anda menemui orang yang anda cari. Lebih banyak data yang anda gunakan, lebih penting anda menggunakannya dengan berkesan dan seefisien mungkin. Dalam artikel ini, kami akan membincangkan cara mengisih sebarang pelaksanaan Senarai dalam Java (termasuk ArrayList) menggunakan kaedah isihan Koleksi.

Cara Isih ArrayList dalam Java menggunakan kaedah isihan Koleksi Java

Mari kita bercakap tentang kaedah Java Collections.sort. Pakej java.util mengandungi banyak utiliti dan pakej berguna yang sering digunakan oleh pembangun, termasuk ArrayList. Katakan anda mempunyai program mudah 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 mahu dapat mencetak senarai warna, tetapi dalam susunan abjad. Bagaimana anda boleh melakukan ini? Menggunakan java.util.Collections, pengisihan adalah semudah satu baris:

Collections.sort(colors);

Ta-da! Senarai warna anda kini telah diisih di tempatnya. Jika anda ingin mencetak senarai, seperti berikut:

System.out.println(colors);

Kemudian anda akan mendapat output berikut:

[Blue, Green, Orange, Red]

Semudah itu?! Semudah itu menggunakan Collections.sort() untuk mengisih senarai Integer, Float atau mana-mana jenis data ringkas lain dalam susunan menaik untuk perkara itu. Tetapi bagaimana jika anda mahu mengisih mengikut tertib menurun? Pasti ada kes di mana ini masuk akal--bayangkan anda mempunyai senarai markah ujian untuk kelas tertentu dan anda ingin mengetahui siapa pelajar yang mendapat markah tertinggi. Adalah lebih masuk akal untuk mengisih senarai dalam susunan menurun (skor tertinggi dahulu), supaya jawapan yang anda cari betul-betul di bahagian atas. Syukurlah, Collections.sort() ditimpa dengan parameter ke-2 pilihan, yang membolehkan anda melakukan ini sahaja:

sort(List l, Comparator c)

Tetapi apa itu pembanding? Nah, pembanding hanyalah fungsi yang membandingkan dua input dan mengembalikan nombor yang mewakili input mana yang didahulukan. Jika anda mengisih ArrayList jenis data primitif, maka Java Collections sudah menyediakan anda dengan reverseOrder() pembanding. Ia boleh dipanggil seperti ini:

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

Kini, warna telah disusun terbalik di tempat supaya jika anda mencetaknya, anda akan mendapat output berikut:

[Red, Orange, Green, Blue]

Cara menggunakan Collections untuk mengisih jenis data bukan primitif dalam Java

Setakat ini, anda telah melihat bahawa menyusun ArrayLists rentetan atau int dalam Java menggunakan kaedah Collections.sort() adalah semudah satu baris kod. Tetapi selalunya, ArrayLists anda akan menyimpan jenis data bukan primitif. Apabila anda bekerja dengan data yang mempunyai atribut yang lebih kompleks, anda perlu menulis kelas untuk mewakili objek ini dan cara ia akan dibandingkan antara satu sama lain menggunakan atributnya. Untuk meneroka contoh ini, mari kita lihat semula contoh mengisih senarai warna, tetapi kali ini, bukannya mengisih Rentetan, kita akan mengisih objek Warna. Kelas Warna asas kami mungkin kelihatan 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 menjadikan kelas Warna kami serasi dengan Collections.sort(), supaya Collections dapat memahami cara membandingkan dan mengisih objek Warna, kami perlu membuat dua pengubahsuaian kecil:

1. jadikan Warna objek Sebanding (tambahkan pelaksanaan Sebanding<Object>)
2. mengatasi kaedah compareTo dalam kelas (override public int compareTo(Object o))

Dengan pengubahsuaian ini, kelas kami kini kelihatan 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 bahawa kaedah compareTo Color hanya memanggil kaedah compareTo String; pengisihan akan dilakukan mengikut susunan abjad. Jika kita ingin mengisih mengikut nilai merah dalam tertib menaik, sebagai contoh, kita boleh menggantikan penyata pulangan dengan return this.r - cr; (jika kita mahu mengisih mengikut nilai hijau dalam tertib menurun, ia akan menjadi cg pulangan - this.g;). Sekarang, jika kita memanggil

Collections.sort(colors);

pada ArrayList of Colors daripada hanya Strings, ia akan berfungsi kerana Collections memahami cara membandingkan objek Color. Jika anda tidak mahu menjadikan objek anda melaksanakan Comparable<Object>, anda boleh menulis komparator untuk kelas anda secara alternatif dan masukkannya ke dalam kaedah Collections.sort() 2-parameter. Pembanding mengatasi kaedah public int compare(Objek satu, Objek dua), dan kaedah Collections.sort() menggunakan kaedah ini untuk membandingkan objek semasa mengisih. Contoh pembanding SortByName dan SortByRed dilaksanakan di bawah:

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 kini boleh menghubungi

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

tanpa kelas Warna sebenarnya melaksanakan Sebanding, dan ia masih akan berfungsi. Kadangkala, anda akan melihat ini dilakukan dalam talian, menggunakan fungsi lambda. Fungsi lambda pada asasnya ialah fungsi tanpa nama yang boleh anda tentukan dalam baris kod, yang memanggilnya. Ia berguna apabila anda hanya perlu memanggil fungsi untuk satu contoh tertentu dan tidak mahu menentukan keseluruhan fungsi berasingan di tempat lain. Pembanding SortByName boleh ditakrifkan dalam talian, menggunakan fungsi lambda, seperti ini:

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

Seperti yang anda duga, (a, b) mewakili parameter fungsi lambda (dua objek yang hendak dibandingkan). The -> menandakan bahawa apa yang berikut ialah definisi fungsi lambda. Itu sahaja! Anda kini telah melihat kaedah yang paling popular untuk menyusun ArrayLists di Java menggunakan pakej Koleksi.