Java Collections sort()

หนึ่งในฟังก์ชันที่พบบ่อยที่สุดที่เราต้องการในฐานะนักพัฒนาซอฟต์แวร์ที่ต้องจัดการกับข้อมูลคือการจัดเรียง โดยสามารถจัดเรียงข้อมูลของเราได้ เราสามารถเพิ่มประสิทธิภาพอัลกอริทึมของเราเพื่อให้ทำงานได้เร็วขึ้นมาก และค้นหาข้อมูลที่ต้องการได้ในเสี้ยวเวลาที่มัน จะพาไปเป็นอย่างอื่น ในบทเรียนวันนี้ เราจะพูดถึง Java Collections sort() เป็นการทดลองอย่างรวดเร็ว ลองนึกภาพว่าคุณกำลังค้นหาชื่อผ่านบัญชีรายชื่อของมหาวิทยาลัย อาจมีนักเรียนหลายหมื่นคนที่โรงเรียนนี้ หากบัญชีรายชื่อที่คุณได้รับไม่เรียงตามลำดับตัวอักษร คุณจะต้องพลิกดูทุกหน้าและดูอย่างระมัดระวังเพื่อให้แน่ใจว่าคุณไม่ได้ข้ามชื่อใดไปแม้แต่ชื่อเดียว จนกว่าคุณจะพบชื่อที่คุณต้องการในที่สุด ในทางกลับกัน หากบัญชีรายชื่อเรียงตามตัวอักษร คุณไม่เพียงแต่ต้องเคร่งครัดในการค้นหาน้อยลงเท่านั้น แต่คุณสามารถข้ามไปยังส่วนในบัญชีรายชื่อที่มีอักษรตัวแรกเหมือนกันได้อย่างง่ายดาย และข้ามไปรอบๆ หน้าอย่างรวดเร็วจนคุณเจอคนที่คุณกำลังมองหา ยิ่งคุณทำงานกับข้อมูลมากเท่าไหร่ คุณก็ยิ่งต้องใช้ข้อมูลนั้นอย่างมีประสิทธิภาพและประสิทธิผลมากที่สุดเท่านั้น ในบทความนี้ เราจะกล่าวถึงวิธีการจัดเรียงการใช้งาน List ใดๆ ใน Java (รวมถึง ArrayList) โดยใช้วิธีการเรียงลำดับ Collections

วิธีการเรียงลำดับ ArrayList ใน Java โดยใช้วิธีการเรียงลำดับของ Java Collections

พูดคุยเกี่ยวกับวิธีการ Java Collections.sort แพ็คเกจ java.util มียูทิลิตี้และแพ็คเกจที่มีประโยชน์มากมายซึ่งนักพัฒนามักจะใช้รวมถึง ArrayList สมมติว่าคุณมีโปรแกรมอย่างง่ายดังต่อไปนี้:

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");
    }
}

คุณต้องการพิมพ์รายการสี แต่เรียงตามตัวอักษร คุณจะทำสิ่งนี้ได้อย่างไร การใช้ java.util.Collections การเรียงลำดับทำได้ง่ายเหมือนใช้ซับใน:

Collections.sort(colors);

ทะ-ดา! รายการสีของคุณได้รับการจัดเรียงเข้าที่แล้ว หากคุณต้องพิมพ์รายการเช่นนี้:

System.out.println(colors);

จากนั้นคุณจะได้ผลลัพธ์ต่อไปนี้:

[Blue, Green, Orange, Red]

ง่ายขนาดนั้นเลยเหรอ! มันจะง่ายพอๆ กับการใช้ Collections.sort() เพื่อเรียงลำดับรายการของจำนวนเต็ม จำนวนลอย หรือประเภทข้อมูลง่ายๆ อื่นๆ สำหรับเรื่องนั้นจากน้อยไปหามาก แต่ถ้าคุณต้องการเรียงลำดับจากมากไปน้อยล่ะ มีบางกรณีที่สมเหตุสมผล ลองนึกภาพว่าคุณมีรายการคะแนนสอบสำหรับชั้นเรียนหนึ่งๆ และคุณต้องการทราบว่านักเรียนที่ทำคะแนนสูงสุดคือใคร การจัดเรียงรายการตามลำดับจากมากไปหาน้อยจะเหมาะสมกว่ามาก (คะแนนสูงสุดมาก่อน) เพื่อให้คำตอบที่คุณต้องการอยู่ด้านบนสุด โชคดีที่ Collections.sort() ถูกเขียนทับด้วยพารามิเตอร์ตัวเลือกที่ 2 ซึ่งให้คุณทำสิ่งนี้ได้:

sort(List l, Comparator c)

แต่ตัวเปรียบเทียบคืออะไร? ตัวเปรียบเทียบเป็นเพียงฟังก์ชันที่เปรียบเทียบอินพุตสองตัวและส่งคืนตัวเลขที่แสดงว่าอินพุตใดมาก่อน หากคุณกำลังเรียงลำดับ ArrayList ของชนิดข้อมูลดั้งเดิม Java Collections จัดเตรียมตัวเปรียบเทียบ reverseOrder() ให้คุณแล้ว สามารถเรียกได้ดังนี้:

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

ขณะนี้ สีถูกจัดเรียงกลับเข้าที่ ดังนั้นหากคุณพิมพ์ออกมา คุณจะได้ผลลัพธ์ต่อไปนี้:

[Red, Orange, Green, Blue]

วิธีใช้ Collections เพื่อจัดเรียงประเภทข้อมูลที่ไม่ใช่แบบดั้งเดิมใน Java

ถึงตอนนี้ คุณคงเห็นแล้วว่าการเรียงลำดับ ArrayLists ของสตริงหรือ int ใน Java โดยใช้ เมธอด Collections.sort()นั้นง่ายพอๆ กับโค้ดบรรทัดเดียว แต่บ่อยครั้ง ArrayLists ของคุณจะจัดเก็บประเภทข้อมูลที่ไม่ใช่แบบดั้งเดิม เมื่อคุณทำงานกับข้อมูลที่มีแอตทริบิวต์ที่ซับซ้อนมากขึ้น คุณจะต้องเขียนคลาสเพื่อเป็นตัวแทนของออบเจกต์เหล่านี้ และวิธีเปรียบเทียบออบเจกต์แต่ละรายการโดยใช้แอตทริบิวต์ หากต้องการสำรวจตัวอย่างนี้ ลองมาดูตัวอย่างการเรียงลำดับรายการสีอีกครั้ง แต่คราวนี้เราจะเรียงลำดับอ็อบเจกต์สีแทนการเรียงลำดับสตริง คลาสสีพื้นฐานของเราอาจมีลักษณะดังนี้:

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;
	}
}

ในการทำให้คลาสสีของเราเข้ากันได้กับ Collections.sort() เพื่อให้คอลเลกชั่นเข้าใจวิธีการเปรียบเทียบและจัดเรียงวัตถุสี เราจำเป็นต้องแก้ไขเล็กน้อยสองอย่าง:

1. ทำให้สีเป็นวัตถุที่เปรียบเทียบได้ (เพิ่มใช้ Comparable<Object>)
2. แทนที่วิธีการเปรียบเทียบในชั้นเรียน (แทนที่สาธารณะ int เปรียบเทียบถึง (วัตถุ o))

ด้วยการแก้ไขเหล่านี้ คลาสของเราจึงมีลักษณะดังนี้:

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);
	}
}

ขอให้สังเกตว่าเมธอด make-up ของ color เรียกเมธอด expandTo ของสตริง การเรียงลำดับจะทำตามลำดับตัวอักษร ถ้าเราต้องการเรียงลำดับตามค่าสีแดงจากน้อยไปหามาก เช่น เราสามารถแทนที่คำสั่ง return ด้วย return this.r - cr; (ถ้าเราต้องการเรียงลำดับตามค่าสีเขียวจากมากไปน้อย มันจะเป็น return cg - this.g;) ทีนี้ถ้าเราโทร

Collections.sort(colors);

ใน ArrayList of Colours แทนที่จะเป็นแค่ Strings มันจะใช้ได้เพราะ Collections เข้าใจวิธีเปรียบเทียบวัตถุสี หากคุณไม่ต้องการทำให้อ็อบเจกต์ของคุณใช้ Comparable<Object> คุณสามารถเขียนตัวเปรียบเทียบสำหรับคลาสของคุณ และส่งต่อไปยังเมธอด Collections.sort() แบบ 2 พารามิเตอร์ ตัวเปรียบเทียบแทนที่เมธอด public int comparison(Object one, Object two) และ Collections.sort() ใช้เมธอดนี้เพื่อเปรียบเทียบอ็อบเจกต์ขณะเรียงลำดับ ตัวอย่างของการเปรียบเทียบ SortByName และ SortByRed ถูกนำมาใช้ด้านล่าง:

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;
	}
}

ตอนนี้คุณสามารถโทร

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

หากไม่มีคลาส Color ที่ใช้ Comparable จริง ๆ และจะยังคงใช้งานได้ บางครั้งคุณจะเห็นการดำเนินการนี้แบบอินไลน์ โดยใช้ฟังก์ชันแลมบ์ดา ฟังก์ชันแลมบ์ดาโดยพื้นฐานแล้วเป็นฟังก์ชันที่ไม่มีชื่อซึ่งคุณสามารถกำหนดได้ภายในบรรทัดของโค้ด ซึ่งเรียกใช้ฟังก์ชันนี้ ซึ่งจะมีประโยชน์เมื่อคุณต้องการเรียกใช้ฟังก์ชันสำหรับอินสแตนซ์เฉพาะหนึ่งรายการเท่านั้น และไม่ต้องการกำหนดฟังก์ชันทั้งหมดแยกจากที่อื่น สามารถกำหนดตัวเปรียบเทียบ SortByName ในบรรทัดโดยใช้ฟังก์ชันแลมบ์ดา เช่นนี้:

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

อย่างที่คุณอาจเดาได้ (a, b) แสดงถึงพารามิเตอร์ของฟังก์ชันแลมบ์ดา (วัตถุทั้งสองที่จะเปรียบเทียบกัน) -> หมายความว่าสิ่งที่ตามมาคือคำจำกัดความของฟังก์ชันแลมบ์ดา เกี่ยวกับมัน! ตอนนี้คุณได้เห็นวิธีการเรียงลำดับ ArrayLists ที่ได้รับความนิยมมากที่สุดใน Java โดยใช้แพ็คเกจ Collections