คำอธิบายโดยละเอียดและความแตกต่างระหว่าง Java เทียบเท่ากับตัวเปรียบเทียบ

คำอธิบายโดยละเอียดและความแตกต่างระหว่าง Java เทียบเท่ากับตัวเปรียบเทียบ

Java ให้กลไกการเปรียบเทียบสองอย่างแก่เรา: เปรียบเทียบและเปรียบเทียบ อะไรคือความแตกต่างระหว่างพวกเขา? มาหาวันนี้

การจัดเรียงตามธรรมชาติ

เปรียบเทียบได้คืออินเทอร์เฟซภายใต้แพ็คเกจ java.lang และมีเพียงวิธีเดียวเท่านั้นที่ compereto () ภายใน:

 อินเทอร์เฟซสาธารณะเทียบเท่า <t> {public int compereto (t o);}

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

มีสามกรณีที่ค่าส่งคืนของวิธีการเปรียบเทียบคือ:

1. e1.Compareto (e2)> 0 i.e. e1> e2
2. e1.Compareto (e2) = 0 i.e. e1 = e2
3. e1.Compareto (e2) <0 i.e1 <e2

สังเกต:

1. เนื่องจาก NULL ไม่ใช่คลาสหรือวัตถุคุณควรให้ความสนใจกับกรณีของ E.Compareto (NULL) เมื่อเขียนวิธีการเปรียบเทียบใหม่ แม้ว่า E.Equals (NULL) จะส่งคืนเท็จ แต่วิธีการเปรียบเทียบควรโยนตัวชี้ NULL ยกเว้น NullPointerException อย่างแข็งขัน

2. เมื่อใช้คลาสที่เปรียบเทียบได้เพื่อเขียนวิธีการเปรียบเทียบใหม่ผลลัพธ์ของ E1.Compareto (E2) == 0 โดยทั่วไปจะต้องสอดคล้องกับ e1.equals (E2) ด้วยวิธีนี้ในอนาคตเมื่อใช้ sortedset และคอนเทนเนอร์คอลเลกชันอื่น ๆ ที่จัดเรียงตามคลาสตามธรรมชาติของคลาสลำดับของข้อมูลที่บันทึกไว้สามารถทำให้มั่นใจได้ว่าจะสอดคล้องกับจินตนาการ
บางคนอาจสงสัยว่าจะเกิดอะไรขึ้นหากมีการละเมิดจุดที่สองข้างต้น?

ตัวอย่างเช่นหากคุณเพิ่มวัตถุสองชิ้น A และ B ลงในชุดเรียงลำดับ AB จะตอบสนอง (! A.Equals (B) && A.Compareto (b) == 0) และไม่มีตัวเปรียบเทียบอื่นที่ระบุไว้แล้วเมื่อคุณเพิ่ม A และ B

ในความเป็นจริงผลลัพธ์ของคลาส Java Core ทั้งหมดที่ใช้อินเทอร์เฟซที่เปรียบเทียบได้นั้นสอดคล้องกับวิธี Equalas
รายการหรืออาร์เรย์ที่ใช้อินเทอร์เฟซที่เปรียบเทียบได้สามารถเรียงลำดับได้โดยใช้วิธีการรวบรวม () หรืออาร์เรย์. sort ()

เฉพาะวัตถุที่ใช้งานอินเตอร์เฟสเปรียบเทียบได้โดยตรงเป็นคีย์ของ SortEdMap (SortedSet) มิฉะนั้นจะต้องระบุกฎการเรียงลำดับตัวเปรียบเทียบนอก

ดังนั้นหากคลาสที่คุณกำหนดด้วยตัวเองต้องการใช้คลาสคอลเลกชันที่สั่งซื้อคุณต้องใช้อินเทอร์เฟซที่เปรียบเทียบได้เช่น:

 ** * คำอธิบาย: หนังสือคลาสเอนทิตีที่ใช้สำหรับการทดสอบใช้อินเทอร์เฟซที่เปรียบเทียบได้การเรียงลำดับตามธรรมชาติ * <br/> * ผู้แต่ง: Shixinzhang * <br/> * ข้อมูล: 10/5/2016 */คลาสสาธารณะ จำนวน int ส่วนตัว; Public Bookbean (ชื่อสตริงจำนวน int) {this.name = name; this.count = นับ; } สตริงสาธารณะ getName () {ชื่อคืน; } โมฆะสาธารณะ setName (ชื่อสตริง) {this.name = name; } public int getCount () {นับคืน; } โมฆะสาธารณะ setCount (จำนวน int) {this.count = count; } / ** * rewrite equals * @param o * @return * / @Override บูลีนสาธารณะเท่ากับ (วัตถุ o) {ถ้า (นี่ == o) ส่งคืนจริง; if (! (o อินสแตนซ์ของ bookbean)) กลับเท็จ; bookbean bean = (bookbean) o; ถ้า (getCount ()! = bean.getCount ()) ส่งคืนเท็จ; return getName (). เท่ากับ (bean.getName ()); } /*** เขียนวิธีการคำนวณของ HashCode* การคำนวณซ้ำตามแอตทริบิวต์ทั้งหมดเพื่อหลีกเลี่ยงการทำซ้ำ* ปัจจัยการคำนวณ 31 จะเห็นได้เมื่อคำนวณ HashCode มันเป็นหมายเลขเฉพาะและไม่สามารถแบ่งได้อีกครั้ง * @return */ @Override สาธารณะ int hashCode () {// hashCode ของสตริง () ซึ่งแสดงถึงเนื้อหาของสตริง int result = getName (). hashCode (); // คูณด้วย 31, ผลการนับ = 31 * ผลลัพธ์ + getCount (); ผลการกลับมา; } @Override สตริงสาธารณะ toString () {return "bookbean {" + "name = '" name +'/'' + ", count =" + count + '}'; } / ** * เมื่อเพิ่ม bookbean ไปยัง Treeset วิธีนี้จะถูกเรียกให้เรียงลำดับ * @param อื่น * @return * / @Override public int compareto (วัตถุอื่น) {ถ้า (อินสแตนซ์อื่นของ bookbean) ผล int; // ตัวอย่างเช่นการเรียงลำดับตามราคาหนังสือที่นี่ผลลัพธ์ = getCount () - อีกเล่ม getCount (); // หรือติดตาม String ลำดับของการเปรียบเทียบ // result = getName (). compereto (ubmobook.getName ()); if (result == 0) {// เมื่อราคาหนังสือเหมือนกันให้เปรียบเทียบชื่อ ตรวจสอบให้แน่ใจว่าแอตทริบิวต์ทั้งหมดเป็นผลเปรียบเทียบ = getName (). compereto (otherbook.getName ()); } ผลตอบแทนผลลัพธ์; } // return 0 return 0; -

รหัสข้างต้นยังเขียนวิธี Equalas () และ HashCode () ใหม่ คลาสที่กำหนดเองจำเป็นต้องเขียนวิธีเหล่านี้ใหม่เมื่อพวกเขาต้องการเปรียบเทียบ

เมื่อเขียนใหม่ในภายหลังคุณต้องตัดสินว่าแอตทริบิวต์บางอย่างเหมือนกันและเปรียบเทียบแอตทริบิวต์ทั้งหมดหนึ่งครั้งหรือไม่

อินเทอร์เฟซที่เปรียบเทียบได้เป็นส่วนหนึ่งของกรอบคอลเลกชัน Java

ตัวเปรียบเทียบแบบกำหนดเอง

ตัวเปรียบเทียบยังเป็นอินเทอร์เฟซภายใต้แพ็คเกจ java.util ก่อน JDK 1.8 มีเพียงสองวิธีเท่านั้น:

 ตัวเปรียบเทียบส่วนต่อประสานสาธารณะ <T> {Public Int Compare (T LHS, T RHS); บูลีนสาธารณะเท่ากับ (วัตถุวัตถุ);}

มีการเพิ่มวิธีการใหม่ ๆ มากมายใน JDK 1.8:

โดยพื้นฐานแล้วพวกเขาทั้งหมดเกี่ยวข้องกับฟังก์ชั่นและการเพิ่มเติมใหม่ถึง 1.8 จะไม่ได้รับการแนะนำที่นี่

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

ตัวเปรียบเทียบตั้งค่ากฎการเรียงลำดับภายนอกและส่งผ่านไปยังคลาสบางประเภทเป็นพารามิเตอร์นโยบายการเรียงลำดับเช่น collections.sort (), array.sort () หรือคอลเลกชันที่ได้รับคำสั่งภายใน (เช่น SortedSet, SortedMap ฯลฯ )

วิธีใช้ส่วนใหญ่แบ่งออกเป็นสามขั้นตอน:

1. สร้างคลาสการใช้งานอินเตอร์เฟสเปรียบเทียบและกำหนดค่าให้กับวัตถุ

เขียนกฎการเรียงลำดับสำหรับคลาสที่กำหนดเองในวิธีการเปรียบเทียบ

2. ผ่านวัตถุเปรียบเทียบเป็นพารามิเตอร์ไปยังวิธีการของคลาสการเรียงลำดับ

3. เพิ่มคลาสที่กำหนดเองที่ใช้ในวิธีการเปรียบเทียบกับคลาสการเรียงลำดับ

ตัวอย่างเช่น:

 // 1. สร้างวัตถุที่ใช้ตัวเปรียบเทียบอินเตอร์เฟสเปรียบเทียบ = new comparator () {@Override public int Compare (Object Object1, Object Object2) {if (Object1 Instanceof NewbookBean && วัตถุอินสแตนซ์ของ NewbookBean) NewbookBean NewbookBean1 = (Newbookbean) Object2; // อ้างถึงการเปรียบเทียบในการเรียงลำดับตามธรรมชาติสำหรับวิธีการเปรียบเทียบที่เฉพาะเจาะจงนี่คือ Chestnut return newbookbean.getCount () - newBookBean1.getCount (); } return 0; - // 2. ผ่านวัตถุนี้เป็นพารามิเตอร์อย่างเป็นทางการไปยังตัวสร้างของ Treeset Treeset = ใหม่ชุดใหม่ (ตัวเปรียบเทียบ); // 3. เพิ่มวัตถุของชั้นเรียนที่ออกแบบมาในวิธีการเปรียบเทียบในขั้นตอนที่ 1 ไปยังชุดต้นไม้ลงในชุดต้นไม้ Treeet.add (Newbookbean ("A", 34)); Treeset.add (Newbookbean ("s", 1)); Treeset.add (Newbookbean ("V", 46)); Treeset.add (Newbookbean ("Q", 26));

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

การอ้างอิงถึงอินเทอร์เฟซเปรียบเทียบจะจัดขึ้นในคลาส Sort:

ตัวเปรียบเทียบ <? Super K> ตัวเปรียบเทียบ;
เราสามารถส่งผ่านในคลาสการใช้งานการคัดแยกกฎการเรียงลำดับแบบกำหนดเองและกำหนดกลยุทธ์การเรียงลำดับที่แตกต่างกันสำหรับคลาสเดียวกัน

สรุป

วิธีการเรียงลำดับสองวิธีใน Java:

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

เมื่อมีอยู่ในเวลาเดียวกันมันจะใช้กฎของตัวเปรียบเทียบ (การเรียงลำดับที่กำหนดเอง) สำหรับการเปรียบเทียบ

สำหรับประเภทข้อมูลทั่วไปบางชนิด (เช่นสตริง, จำนวนเต็ม, สองเท่า ... ) พวกเขาใช้อินเทอร์เฟซที่เปรียบเทียบได้ตามค่าเริ่มต้นและใช้วิธีการเปรียบเทียบซึ่งเราสามารถใช้โดยตรง

สำหรับคลาสที่กำหนดเองบางชั้นพวกเขาอาจจำเป็นต้องใช้กลยุทธ์การเปรียบเทียบที่แตกต่างกันในสถานการณ์ที่แตกต่างกัน เราสามารถสร้างอินเทอร์เฟซเปรียบเทียบใหม่จากนั้นเปรียบเทียบโดยใช้การใช้งานตัวเปรียบเทียบเฉพาะ

นี่คือความแตกต่างระหว่างการเปรียบเทียบและตัวเปรียบเทียบ

ขอบคุณสำหรับการอ่านฉันหวังว่ามันจะช่วยคุณได้ ขอบคุณสำหรับการสนับสนุนเว็บไซต์นี้!