ตรวจสอบอย่างมีประสิทธิภาพว่าองค์ประกอบในอาร์เรย์มีอยู่ในชวา

1. วิธีการตรวจสอบว่าอาร์เรย์มีค่าที่แน่นอน

ใช้รายการ

 Public Static Boolean Uselist (String [] arr, String TargetValue) {return array.aslist (arr) .contains (targetValue);}

ใช้ชุด

 บูลีนแบบคงที่สาธารณะใช้ (สตริง [] arr, สตริง targetValue) {set <string> set = new hashset <string> (array.aslist (arr)); return set.contains (targetValue);}

ใช้การตัดสินแบบวนซ้ำ

 บูลีนแบบคงที่สาธารณะ useloop (สตริง [] arr, สตริง targetValue) {สำหรับ (สตริง s: arr) {ถ้า (s.equals (targetValue)) ส่งคืนจริง; } return false;}

ใช้ Arrays.binarySearch ()

สามารถใช้เมธอด Arrays.binarySearch() สำหรับอาร์เรย์ที่สั่งซื้อเท่านั้น! - - หากอาร์เรย์ไม่ได้เรียงลำดับผลลัพธ์จะแปลกมาก

การใช้งานของการค้นหาว่าอาร์เรย์ที่สั่งซื้อมีค่าที่แน่นอนมีดังนี้:

 บูลีนแบบคงที่สาธารณะ usearraysbinarySearch (สตริง [] arr, สตริง targetValue) {int a = array.binarySearch (arr, targetValue); if (a> 0) ส่งคืนจริง; อื่นกลับเท็จ}

ความซับซ้อนของเวลา

รหัสต่อไปนี้สามารถวาดค่าใช้จ่ายเวลาของวิธีการต่าง ๆ ได้ประมาณ แนวคิดพื้นฐานคือการหาค่าที่แน่นอนจากอาร์เรย์และขนาดของอาร์เรย์คือ 5, 1K และ 10K ตามลำดับ ผลลัพธ์ที่ได้จากวิธีนี้อาจไม่ถูกต้อง แต่เป็นวิธีที่ง่ายและชัดเจนที่สุด

 โมฆะคงที่สาธารณะหลัก (สตริง [] args) {string [] arr = สตริงใหม่ [] {"cd", "bc", "ef", "de", "ab"}; // ใช้รายการ Long StartTime = System.nanotime (); สำหรับ (int i = 0; i <100000; i ++) {uselist (arr, "a"); } endtime long = system.nanotime (); ระยะเวลานาน = endtime - starttime; System.out.println ("USELIST:" + DURATION / 10,00000); // ใช้ชุดเริ่มต้น = system.nanotime (); สำหรับ (int i = 0; i <100000; i ++) {useet (arr, "a"); } endtime = system.nanotime (); ระยะเวลา = endtime - starttime; System.out.println ("ใช้งาน:" + ระยะเวลา / 10,00000); // ใช้ loop starttime = system.nanotime (); สำหรับ (int i = 0; i <100000; i ++) {useloop (arr, "a"); } endtime = system.nanotime (); ระยะเวลา = endtime - starttime; System.out.println ("USELOOP:" + DURATION / 10,00000); // ใช้ array.binarySearch () startTime = system.nanotime (); สำหรับ (int i = 0; i <100000; i ++) {usearraysbinarySearch (arr, "a"); } endtime = system.nanotime (); ระยะเวลา = endtime - starttime; System.out.println ("Usearraybinary:" + Duration / 10000000);}

ผลการทำงาน:

 USELIST: 13USESET: 72USELOOP: 5USEARRAYSBINARYSEARCH: 9

ใช้อาร์เรย์ที่มีความยาว 1k

 string [] arr = สตริงใหม่ [1000]; สุ่ม s = new random (); สำหรับ (int i = 0; i <1000; i ++) {arr [i] = string.valueof (s.nextint ());}

ผลลัพธ์:

 USELIST: 112USESET: 2055USELOOP: 99USEARRAYBINANTS: 12

ใช้อาร์เรย์ความยาว 10k

 string [] arr = สตริงใหม่ [10,000]; สุ่ม s = new random (); สำหรับ (int i = 0; i <10,000;

ผลลัพธ์:

 USELIST: 1590USESET: 23819USELOOP: 1526USEARRATYBINANTS: 12

สรุป

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

หากคุณใช้เมธอด Arrays.binarySearch() ต้องจัดเรียงอาร์เรย์ เนื่องจากอาร์เรย์ข้างต้นไม่ได้ถูกเรียงลำดับวิธีนี้จึงไม่สามารถใช้ได้

ในความเป็นจริงหากคุณต้องการใช้อาร์เรย์หรือคลาสคอลเลกชันเพื่อตรวจสอบอย่างมีประสิทธิภาพว่าอาร์เรย์มีค่าเฉพาะรายการที่เรียงลำดับหรือต้นไม้สามารถบรรลุความซับซ้อนของเวลาของ O (log (n)) และ Hashset สามารถบรรลุ O (1)

ใช้ arrayutils

นอกเหนือจากข้างต้นไลบรารีคลาส Apache Commons ยังมีคลาส Arrayutils ซึ่งสามารถใช้วิธีการของมันเพื่อตัดสินความสัมพันธ์ระหว่างอาร์เรย์และค่า

 นำเข้า org.apache.commons.lang3.arrayutils; บูลีนคงที่สาธารณะ usearrayutils (สตริง [] arr, สตริง targetValue) {return arrayutils.contains (arr, targetValue);}

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

 USELIST: 323USESET: 3028USELOOP: 141USEARRAYBINANTS: 12USEARRAYUTILS: 181 ---------- USELIST: 3703USESET: 35183USELOOP: 3218USEARRATYBINANTS: 14USEARRAYUTILS: 3125

ในความเป็นจริงถ้าคุณดูซอร์สโค้ดของ arrayutils.contains คุณสามารถพบว่ามันเป็นวิธีที่จะตัดสินว่าองค์ประกอบนั้นรวมอยู่ในอาร์เรย์หรือไม่

รหัสบางส่วนมีดังนี้:

 if (array == null) {return -1; } else {ถ้า (startIndex <0) {startIndex = 0; } int i; if (ObjectTofind == null) {สำหรับ (i = startIndex; i <array.length; ++ i) {ถ้า (อาร์เรย์ [i] == null) {return i; }}} อื่นถ้า (array.getClass (). getComponentYpe (). isInstance (ObjectTofind)) {สำหรับ (i = startIndex; i <array.length; ++ i) {ถ้า (ObjectTofind.equals (array [i])) {return i; }}} return -1; -

ดังนั้นในการเปรียบเทียบฉันชอบใช้คลาสเครื่องมือ Arrayutils เพื่อดำเนินการบางอย่างที่เกี่ยวข้องกับบรรพบุรุษจำนวนรวม ท้ายที่สุดเขาสามารถให้ฉันเขียนโค้ดจำนวนมากน้อยลง (เพราะมีข้อบกพร่องอย่างหลีกเลี่ยงไม่ได้เมื่อเขียนโค้ดด้วยตัวเองหลังจากทั้งหมดไลบรารีเครื่องมือโอเพ่นซอร์สที่ได้รับจาก Apache ได้รับการทดสอบโดยนักพัฒนาที่นับไม่ถ้วน) และประสิทธิภาพไม่ต่ำกว่ามาก

สรุป

ตกลงข้างต้นเป็นเรื่องเกี่ยวกับบทความนี้ ฉันหวังว่าเนื้อหาของบทความนี้จะช่วยให้ทุกคนเรียนรู้หรือใช้ Java หากคุณมีคำถามใด ๆ คุณสามารถฝากข้อความไว้เพื่อสื่อสาร