การอภิปรายสั้น ๆ เกี่ยวกับการสั่งซื้ออาร์เรย์วัตถุหรือรายการและหลักการของการเรียงลำดับคอลเลกชัน

บ่อยครั้งที่จำเป็นต้องเรียงลำดับรายการจากรายการ <string> เพื่อเรียงลำดับคลาสที่กำหนดเอง ไม่จำเป็นต้องรวมหรือจัดเรียงด้วยตัวคุณเอง เพียงใช้หนึ่งอินเทอร์เฟซ

บทความนี้จะแนะนำการใช้ คอลเลกชันเพื่อเรียงลำดับรายการ <string> จากนั้นพูดคุยเกี่ยวกับ หลักการของคอลเลกชัน

มาพูดคุย เกี่ยวกับวิธีการเรียงลำดับชั้นเรียนที่กำหนดเอง

ในที่สุด วิธีอื่นในการเรียงลำดับวัตถุที่กำหนดเอง โดยใช้ การเรียงคอลเลกชันจะได้รับการแนะนำ และทั้งสองประเภทคือการเปรียบเทียบประสิทธิภาพที่ง่าย

1. หลักการของรายการเรียงลำดับ <String> และคอลเลกชัน

รหัสมีดังนี้

 รายการ <String> stringList = new ArrayList <String> (); StringList.add ("Nice"); StringList.add ("อร่อย"); StringList.add ("สามารถ"); StringList.add ("Moon"); StringList.add ("ลอง"); StringList.add ("เพื่อน"); collections.sort (StringList); สำหรับ (string str: stringlist) {system.out.println (str); -

ที่ซึ่งคอลเลกชันคือ java.util.collections

ตรวจสอบการใช้งานเรียงลำดับในคอลเลกชัน

 @suppresswarnings ("ไม่ได้ตรวจสอบ") สาธารณะคงที่ <t ขยายเปรียบเทียบได้ <? super t >> การเรียงลำดับเป็นโมฆะ (รายการ <t> รายการ) {object [] array = list.toarray (); array.sort (อาร์เรย์); int i = 0; listiterator <t> it = list.listiterator (); ในขณะที่ (it.hasnext ()) {it.next (); it.set ((t) อาร์เรย์ [i ++]); -

จากนี้เราจะเห็นได้ว่าร่างกายการเรียงลำดับคืออาร์เรย์ (อาร์เรย์); การจัดเรียงการติดตั้งของอาร์เรย์คือ

 การเรียงลำดับโมฆะสาธารณะแบบคงที่ (อาร์เรย์ [] อาร์เรย์) {// เริ่มต้น Android-Changed ComparableTimsort.sort (อาร์เรย์); // สิ้นสุด Android-Changed}

ติดตามการใช้งานการเรียงลำดับของ Comparabletimsort.sort.sort

การเรียงลำดับโมฆะแบบคงที่ (วัตถุ [] a) ถึงการเรียงลำดับโมฆะแบบคงที่ (วัตถุ [] a, int lo, int hi) ไปยังโมฆะไบนารีแบบคงที่ส่วนตัว (วัตถุ [] a, int lo, int hi, int start) ใน BinarySort ส่วนที่ใช้สำหรับการเปรียบเทียบขนาดคือ

 เทียบเท่า <jobch> pivot = (เปรียบเทียบได้) a [start]; int ซ้าย = lo; int ขวา = เริ่ม; ยืนยันซ้าย <= ขวา; ในขณะที่ (ซ้าย <ขวา) {int mid = (ซ้าย + ขวา) >>> 1; if (pivot.compareto (a [mid]) <0) ขวา = mid; ellet left = mid + 1; -

การเปรียบเทียบวัตถุจะถูกเรียกเพื่อเปรียบเทียบ โดยค่าเริ่มต้นทั้งประเภทสตริงและจำนวนเต็มถูกแทนที่ด้วยวิธีการเปรียบเทียบ ดังนั้นคุณสามารถเปรียบเทียบด้วยตัวเอง

2. การเปรียบเทียบคลาสที่กำหนดเอง

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

2.1 เราตรวจสอบการใช้งานวัตถุและพบว่าไม่มีวิธีการเปรียบเทียบ

ดูคำจำกัดความจำนวนเต็ม

 จำนวนเต็มระดับสุดท้ายสาธารณะขยายจำนวนใช้งานได้เทียบเคียง <จำนวนเต็ม>

ลองดูคำจำกัดความของสตริง

 สตริงคลาสสุดท้ายสาธารณะใช้ java.io.serializable, เทียบเคียงได้ <string>, Charsequence

เราสามารถพบว่าพวกเขาทั้งหมดสืบทอดมาจากการเปรียบเทียบ

2.2 ดูอินเทอร์เฟซที่เปรียบเทียบได้

คุณสามารถพบว่ามีวิธีเดียวเท่านั้นที่เทียบเคียงได้

รหัส Java

 Public Int Compareto (t o);

กล่าวอีกนัยหนึ่งวิธีการไบนารีจริง ๆ เรียกวิธีการเปรียบเทียบแบบเปรียบเทียบเพื่อทราบว่าตราบใดที่มันถูกสืบทอดมาจากการเปรียบเทียบ

และใช้ COMPLETO เพื่อเรียกคอลเลกชัน SORT เพื่อเรียงลำดับวัตถุที่กำหนดเอง

2.3 การเปรียบเทียบคลาสที่กำหนดเอง

รหัสต่อไปนี้คือการเรียงลำดับผู้ใช้ ก่อนอื่นให้เรียงตามชื่อทีละคน หากชื่อเหมือนกันจัดเรียงจากขนาดเล็กไปใหญ่ทีละน้อย

รหัส Java

 การบำรุงรักษาคลาสสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {list <user> userlist = new ArrayList <user> (); userlist.add (ผู้ใช้ใหม่ ("Lucy", 19)); userlist.add (ผู้ใช้ใหม่ ("แจ็ค", 19)); userlist.add (ผู้ใช้ใหม่ ("Jim", 19)); userlist.add (ผู้ใช้ใหม่ ("James", 19)); userlist.add (ผู้ใช้ใหม่ ("Herry", 19)); userlist.add (ผู้ใช้ใหม่ ("Luccy", 19)); userlist.add (ผู้ใช้ใหม่ ("James", 18)); userlist.add (ผู้ใช้ใหม่ ("Herry", 20)); collections.sort (ผู้ใช้); สำหรับ (ผู้ใช้ผู้ใช้: ผู้ใช้) {System.out.println (user.getName () + "/t/t" + user.getage ()); }} ผู้ใช้คลาสแบบคงที่ส่วนตัวใช้การเปรียบเทียบ <user> {ชื่อสตริงส่วนตัว; อายุ int ส่วนตัว; ผู้ใช้สาธารณะ (ชื่อสตริงอายุ int) {this.name = name; this.age = อายุ; } @Override public int compereto (ผู้ใช้อื่น) {int comperename = this.name.Compareto (อื่น. getName ()); if (comperename == 0) {return (this.age == other.getage ()? 0: (this.age> other.getage ()? 1: -1)); } return name; } สตริงสาธารณะ getName () {ชื่อคืน; } public int getage () {return Age; -

หลังจากดำเนินการแล้วเอาต์พุตคือ:

รหัส XML:

 Herry 19 Herry 20 Jack 19 James 18 James 19 Jim 19 Luccy 19 Lucy 19

จะเห็นได้ว่าจำเป็นต้องมีเพียงสองจุดเท่านั้น

. สืบทอดมาจากการเปรียบเทียบ

รหัส Java

 ผู้ใช้ระดับส่วนตัวแบบคงที่ใช้การเปรียบเทียบ <ผู้ใช้>

ข. ใช้วิธีการเปรียบเทียบ

การเปรียบเทียบ INT สาธารณะด้านบน (ผู้ใช้อีกคน) เป็นเรื่องของการเปรียบเทียบ

คุณสามารถดูว่า int comperename = this.name.compareto (อื่น. getName ()); หมายถึงชื่อเปรียบเทียบ

ถ้า มันมากกว่าหรือส่งคืน 1 มันจะเท่ากับส่งคืน 0 และถ้ามันน้อยกว่ามันจะกลับมา -1

ถ้าเท่ากันให้เปรียบเทียบตามขนาดของอายุ int

ข้างต้น มีค่ามากกว่าหรือเท่ากับผลตอบแทน 1 และข้างต้นน้อยกว่าผลตอบแทน -1 ซึ่งเป็นพื้นฐานสำหรับการเปรียบเทียบไบนารี

3. ใช้ฟังก์ชั่น overloaded ของคอลเลกชันเรียงลำดับเพื่อเรียงลำดับวัตถุที่กำหนดเอง

รหัสมีดังนี้และชื่อยังคงเปรียบเทียบก่อนหากเท่ากัน

รหัส Java

 การบำรุงรักษาคลาสสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {list <user> userlist = new ArrayList <user> (); userlist.add (ผู้ใช้ใหม่ ("Lucy", 19)); userlist.add (ผู้ใช้ใหม่ ("แจ็ค", 19)); userlist.add (ผู้ใช้ใหม่ ("Jim", 19)); userlist.add (ผู้ใช้ใหม่ ("James", 19)); userlist.add (ผู้ใช้ใหม่ ("Herry", 19)); userlist.add (ผู้ใช้ใหม่ ("Luccy", 19)); userlist.add (ผู้ใช้ใหม่ ("James", 18)); userlist.add (ผู้ใช้ใหม่ ("Herry", 20)); collections.sort (userlist, ตัวเปรียบเทียบใหม่ <user> () {public int compare (ผู้ใช้ผู้ใช้ 1, user user2) {int comparename = user1.getName (). compareto (user2.getName ()); ถ้า (เปรียบเทียบ == 0) {return (user1.getage () } returname ชื่อ;}}); สำหรับ (ผู้ใช้ผู้ใช้: ผู้ใช้) {System.out.println (user.getName () + "/t/t" + user.getage ()); }} ผู้ใช้คลาสคงที่ส่วนตัว {ชื่อสตริงส่วนตัว; อายุ int ส่วนตัว; ผู้ใช้สาธารณะ (ชื่อสตริงอายุ int) {this.name = name; this.age = อายุ; } สตริงสาธารณะ getName () {ชื่อคืน; } public int getage () {return Age; -

คุณจะเห็นว่า

รหัส Java

 collections.sort (userlist, ตัวเปรียบเทียบใหม่ <user> ())

มันเป็นเรื่องของการเปรียบเทียบและใช้วิธีการเปรียบเทียบของตัวเปรียบเทียบ ต่อไปนี้เป็นหลักการของวิธีนี้

คอลเลกชันติดตาม

รหัส Java

 สาธารณะคงที่ <T> การเรียงลำดับเป็นโมฆะ (รายการ <t> รายการ, ตัวเปรียบเทียบ <? super t> c)

มาถึง

รหัส Java

 สาธารณะคงที่ <T> การเรียงลำดับเป็นโมฆะ (t [] a, comparator <? super t> c)

มาถึง

รหัส Java

 โมฆะแบบคงที่ส่วนตัว Mergesort (Object [] SRC, Object [] dest, int low, int สูง, int ปิด, comparator c)

คุณสามารถค้นหารหัสดังนี้:

รหัส Java

 if (ความยาว <insertionSort_threshold) {สำหรับ (int i = ต่ำ; i <high; i ++) สำหรับ (int j = i; j> ต่ำ && c.Compare (dest [j-1], dest [j])> 0; j--) swap (dest, j, j-1); กลับ; -

วิธีการเปรียบเทียบของ Call Comparator

4. การเปรียบเทียบการแสดงการเรียงลำดับข้างต้นข้างต้น

BinarySort ต้องทำการ เปรียบเทียบ NLG (N) และที่เลวร้ายที่สุดการเคลื่อนไหว n^2

Mergesort ดำเนินการแผนกไบนารีอย่างต่อเนื่องและหลังจากหน่วยงานไบนารีแบ่งออกเป็นส่วนเล็ก ๆ มันจะถูกแทรกและจัดเรียง ดังนั้น จะมีการเปรียบเทียบ NLG (n) ครั้ง และ จะมีการเคลื่อนย้าย NLG (N) ครั้ง แต่จำเป็นต้องคัดลอกสำเนาของข้อมูลต้นฉบับก่อนดังนั้นจะ ต้องใช้พื้นที่สองเท่า

ดังนั้นคุณสามารถเลือกตามความต้องการของคุณ

บทความข้างต้นกล่าวถึงการสั่งซื้ออาร์เรย์วัตถุหรือรายการสั้น ๆ และหลักการเรียงลำดับของคอลเลกชันเป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่าคุณจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น