1. แปลงอาร์เรย์เป็นรายการจากนั้นใช้รายการในรายการเพื่อพิจารณาว่ามีอยู่หรือไม่
public boolean uselist สาธารณะ (String [] arr, String containSvalue) {return array.aslist (arr) .contains (contentValue); -ควรสังเกตว่ารายการที่ถูกแปลงในอาร์เรย์วิธีการไม่ได้เป็น java.util.arraylist แต่ java.util.array.arraylist ในหมู่พวกเขาไม่สามารถขยายความยาวของอาร์เรย์ได้ นี่เป็นสิ่งสำคัญอย่างยิ่ง การใช้งานมีดังนี้:
@OverridePublic Boolean ประกอบด้วย (Object O) {// วิธีการเรียกใช้ดัชนีของวิธีการที่จะกำหนดตำแหน่งที่มันเป็นและกำหนดว่ามันคือ -1 return indexof (o)! = -1;}@entridepublic int indexof (Object O) {// get element e [] a = this.a; // ผู้พิพากษาว่างถ้า (o == null) {// การตัดสินลูปสำหรับ (int i = 0; i <a.length; i ++) // ถ้าองค์ประกอบเป็น null ถ้า (a [i] == null) // return i; } else {// ถ้ามันไม่ว่างเปล่าสำหรับ (int i = 0; i <a.length; i ++) // ตัดสินว่าองค์ประกอบนั้นเท่ากับ [i] ถ้า (o.equals (a [i])) // ผลตอบแทนเท่ากันฉันกลับมา; } // มิฉะนั้น return -1 return -1;}2. ใช้ชุดเพื่อตรวจสอบว่ามีอยู่หรือไม่
บูลีนคงที่สาธารณะใช้งาน (สตริง [] arr, สตริง containSvalue) {ส่งคืน hashset ใหม่ <> (array.aslist (arr)). มี (contentValue); -การเปรียบเทียบหลักการของ Array-> list-> set โดยใช้ SET
ซอร์สโค้ด: นำไปใช้โดยการเรียกแผนที่มีคีย์และ HashMap ถูกนำไปใช้โดยการสำรวจคีย์ในตารางแฮช
บูลีน Ypublic ประกอบด้วย (Object O) {return map.containskey (O); -3. ใช้ลูปเพื่อนำไปใช้เขียนลูปเพื่อตัดสิน
บูลีนแบบคงที่สาธารณะ useloop (String [] arr, String containSvalue) {// ตัดสินว่ามันว่างเปล่าถ้า (arr == null || arr.length == 0) {return false; } สำหรับ (int i = 0; i <arr.length; i ++) {// null ทั้งหมดถ้า (contentValue! = null && contentValue.equals (arr [i])) {return true; } อื่นถ้า (arr [i] == null) {return true; }} return false; -4. ใช้วิธีการใน org.apache.commons.lang3.arrayutils เพื่อนำไปใช้
Public Static Boolean useUtils (String [] arr, String containSvalue) {return arrayutils.contains (arr, contentValue); -ซอร์สโค้ดการใช้งานเฉพาะ:
บูลีนแบบคงที่สาธารณะประกอบด้วย (อาร์เรย์วัตถุสุดท้าย [] อาร์เรย์วัตถุสุดท้าย ObjectTofind) {// ดัชนีการเรียกของดัชนีของการกำหนดตำแหน่งการส่งคืนตำแหน่งของดัชนี (อาร์เรย์, ObjectTofind)! = index_not_found; } ดัชนี int คงที่สาธารณะ (อาร์เรย์สุดท้าย [] อาร์เรย์, วัตถุสุดท้าย ObjectTofind, int startIndex) {// ตัดสิน null ถ้า (array == null) {return index_not_found; } // ผู้พิพากษาเริ่มตำแหน่งถ้า (startIndex <0) {startIndex = 0; } // ตัดสินว่าองค์ประกอบการสืบค้นนั้นเป็นโมฆะถ้า (ObjectTofind == null) {// null, ใช้ == เพื่อลูปเพื่อตัดสินตำแหน่งสำหรับ (int i = startIndex; i <array.length; i ++) {ถ้า (อาร์เรย์ [i] == null) {return i; }} // ตัดสินว่าองค์ประกอบเป็นอินสแตนซ์ขององค์ประกอบในอาร์เรย์หรือไม่ ถ้าเป็นเช่นนั้นลูปและใช้เท่ากับเพื่อตัดสิน} อื่นถ้า (array.getClass (). getComponentYpe (). isInstance (ObjectTofind)) {สำหรับ (int i = startIndex; i <array.length; i ++) {ถ้า (ObjectTofind.equals }}} // return ไม่พบ return index_not_found; -ใช้รอบ 1W เพื่อตรวจจับประสิทธิภาพ
โมฆะคงที่สาธารณะ recompileArr (String [] arr, String containSvalue) {// การใช้รายการ Long Start = System.Nanotime (); สำหรับ (int i = 0; i <10000; i ++) {uselist (arr, containvalue); } end long = system.nanotime (); System.out.println ("การใช้รายการ->"+(end-start)/10,000); // การใช้ set start = system.nanotime (); สำหรับ (int i = 0; i <10,000; i ++) {useet (arr, containvalue); } end = system.nanotime (); System.out.println ("ใช้ชุด->"+(end-start)/10,000); // ใช้ loop start = system.nanotime (); สำหรับ (int i = 0; i <10000; i ++) {useloop (arr, containvalue); } end = system.nanotime (); System.out.println ("ใช้ลูป->"+(end-start)/10,000); // การใช้ utils start = system.nanotime (); สำหรับ (int i = 0; i <10,000; i ++) {useUtils (arr, containvalue); } end = system.nanotime (); System.out.println ("ใช้ utils->"+(end-start)/10,000);}ผลลัพธ์มีดังนี้:
ใช้รายการ-> 973
ใช้ set-> 2676
ใช้ลูป-> 448
ใช้ utils-> 1364
รุ่น JDK ที่ใช้คือ JDK1.8.0_172 เวอร์ชันซึ่งสามารถอนุมานได้จากด้านบน
สี่วิธีข้างต้นมีประสิทธิภาพสูง -> ต่ำ
ลูป> รายการ> utils> set
ในการเปรียบเทียบจะเห็นได้ว่าการใช้วิธีลูปนั้นมีประสิทธิภาพมากที่สุดในการตัดสิน จากนั้นไปที่รายการจากนั้นไปที่ Utils แล้วไปที่ Set
สรุป:
มาวิเคราะห์เหตุผลของความเชื่องช้า:
ลูปเป็นอาร์เรย์ที่ทำงานเร็วที่สุดโดยตรงไม่ต้องสงสัยเลย
รายการเป็นครั้งที่สองเพราะจำเป็นต้องสร้าง java.util.array.arraylist การสร้างวัตถุต้องใช้เวลาดังนั้นมันจะช้าลง
Util ที่สามแม้ว่ามันจะใช้ลูปที่คล้ายกัน array.getClass (). getComponentYpe (). isinstance (ObjectTofind) รหัสนี้ใช้การโทรไปยังวิธีการในท้องถิ่น เรารู้ว่าการเรียกวิธีการในท้องถิ่นจะใช้เวลานานกว่าการเรียกใช้วิธี Java โดยตรง ยิ่งไปกว่านั้นเมื่อดูที่ซอร์สโค้ดคุณจะเห็นได้ว่า getClass (), getComponentYpe () และ ISInstance เป็นทั้งสองวิธีดั้งเดิมซึ่งใช้เวลานานมาก
ชุดเป็นชุดที่แย่ที่สุดเพราะมันแปลงอาร์เรย์เป็นรายการก่อนจากนั้นแปลงรายการให้ตั้งค่าและในชุดมันใช้ HASHMAP เพื่อใช้งาน เพราะมันแปลงวัตถุหลายครั้งโดยธรรมชาติประสิทธิภาพจึงไม่ดีขึ้นอย่างแน่นอน
ที่จริงแล้วฉันชอบใช้ arrayutils สำหรับการทำงานเป็นการส่วนตัว แม้ว่าอัตราส่วนจะค่อนข้างต่ำ แต่มันจะแย่กว่านี้มากหรือไม่?
ข้างต้นเป็นคำอธิบายโดยละเอียดเกี่ยวกับหลายวิธีในการเปรียบเทียบองค์ประกอบการตัดสินอาร์เรย์ใน Java ใน Java ฉันหวังว่ามันจะเป็นประโยชน์กับคุณ หากคุณมีคำถามใด ๆ โปรดฝากข้อความถึงฉันและบรรณาธิการจะตอบกลับคุณทันเวลา ขอบคุณมากสำหรับการสนับสนุนเว็บไซต์ Wulin.com!