arraylist พื้นฐานรักษาอาร์เรย์แบบไดนามิกและแต่ละอินสแตนซ์ ArrayList มีความจุ ความจุนี้หมายถึงขนาดของอาร์เรย์ที่ใช้ในการจัดเก็บรายการรายการ อย่างน้อยก็เท่ากับขนาดของรายการเสมอ เมื่อองค์ประกอบถูกเพิ่มเข้ากับ ArrayList อย่างต่อเนื่องความสามารถของพวกเขาก็เพิ่มขึ้นโดยอัตโนมัติ
ArrayList ไม่ได้ซิงโครนัส (นั่นคือไม่ใช่เธรดที่ปลอดภัย) หากหลายเธรดเข้าถึงอินสแตนซ์ ArrayList ในเวลาเดียวกันและอย่างน้อยหนึ่งเธรดจะแก้ไขโครงสร้างรายการจะต้องรักษาการซิงโครไนซ์ภายนอก ในสภาพแวดล้อมแบบมัลติเธรดสามารถประกาศ arraylist แบบเธรดที่ปลอดภัยได้โดยใช้วิธีการรวบรวมข้อมูล SynchronizedList ตัวอย่างเช่น:
รายการ arrayList = collections.synchronizedList (new ArrayList ());
ต่อไปนี้เป็นซอร์สโค้ดของ ArrayList เพื่อวิเคราะห์หลักการ
1. วิธีการก่อสร้าง ArrayList: ArrayList ให้วิธีการก่อสร้างที่แตกต่างกันสามวิธี
1) ArrayList () สร้างรายการว่างที่มีความจุเริ่มต้น 10
2) ArrayList (Int InitialCapacity) สร้างรายการว่างที่มีความจุเริ่มต้นที่ระบุ
3) ArrayList (คอลเลกชัน <? ขยาย e> c) สร้างรายการองค์ประกอบที่มีคอลเลกชันที่ระบุซึ่งจัดเรียงตามลำดับที่ตัววนซ้ำของคอลเลกชันส่งคืนพวกเขา
ซอร์สโค้ดมีดังนี้:
วัตถุชั่วคราวส่วนตัว [] ElementData; ArrayList สาธารณะ (int initialCapacity) {super (); ถ้า (initialcapacity <0) โยน unlegalargumentException ใหม่ ("ความสามารถที่ผิดกฎหมาย:"+ initialcapacity); this.elementData = วัตถุใหม่ [การเริ่มต้นความจุ]; // สร้างอาร์เรย์ของประเภทวัตถุที่มีความยาว 10} arraylist สาธารณะ () {this (10); // การโทร arraylist (int i)} <br> <br> arraylist สาธารณะ (คอลเลกชัน <? ขยาย e> c) {elementData = c.toArray (); // ส่งคืนอาร์เรย์ที่มีองค์ประกอบทั้งหมดในขนาดคอลเลกชันนี้ = elementData.length; // c.toarray อาจ (ไม่ถูกต้อง) ไม่ส่งคืนวัตถุ [] (ดู 6260652) ถ้า (ElementData.getClass ()! = Object []. class) ElementData = arrays.copyof (ElementData, ขนาด, วัตถุ []. คลาส); // คัดลอกอาร์เรย์ที่ระบุและส่งคืนอาร์เรย์ของประเภทวัตถุที่มีองค์ประกอบและความยาวเดียวกัน} เมื่อใช้ arrayList () เพื่อสร้างวัตถุคอลเลกชันที่ไม่มีพารามิเตอร์ตัวสร้าง ArrayList (int initialCapacity) จะถูกเรียกที่ด้านล่างเพื่อสร้างอาร์เรย์ของประเภทวัตถุที่มีความยาว 10. เมื่อใช้ตัวสร้างที่มีพารามิเตอร์ประเภทชุดอาร์เรย์ของวัตถุที่มีองค์ประกอบและความยาวเดียวกัน
2. เพิ่มวิธีการ: ArrayList มีวิธีเพิ่มสองวิธีในการเพิ่มองค์ประกอบ
1) เพิ่ม (e e) เพิ่มองค์ประกอบที่ระบุในตอนท้ายของรายการนี้
2) เพิ่ม (INT INDEX, E E), แทรกองค์ประกอบที่ระบุลงในตำแหน่งที่ระบุในรายการนี้ ย้ายไปทางขวาองค์ประกอบในตำแหน่งนั้น (ถ้ามี) และองค์ประกอบที่ตามมาทั้งหมด (จัดทำดัชนีโดย 1) ขนาด int ส่วนตัว;
บูลีนสาธารณะเพิ่ม (e e) {ensurecapacity (ขนาด + 1); // ขยายความจุของอาร์เรย์ elementData [ขนาด ++] = e; // เพิ่มองค์ประกอบ E ลงในอาร์เรย์วัตถุที่มีขนาดตัวห้อยและเรียกใช้ขนาด ++ ส่งคืนจริง; } โมฆะสาธารณะเพิ่ม (ดัชนี int, องค์ประกอบ e) {ถ้า (ดัชนี> ขนาด || ดัชนี <0) // ถ้าตัวห้อยอาร์เรย์ที่ระบุที่จะแทรกเกินความจุอาร์เรย์หรือตัวห้อยที่ระบุน้อยกว่า 0 ensurecapacity (ขนาด+1); // ขยายระบบความจุอาร์เรย์ ArrayCopy (ElementData, INDEX, ElementData, ดัชนี + 1, ขนาด - ดัชนี); // คัดลอกอาร์เรย์จากอาร์เรย์ต้นทางที่ระบุและสำเนาเริ่มต้นจากตำแหน่งที่ระบุไปยังตำแหน่งที่ระบุของอาร์เรย์เป้าหมาย <br> // ElementData --- ดัชนีอาร์เรย์ต้นทาง --- เริ่มต้นตำแหน่งในอาร์เรย์แหล่งที่มา <br> // elementData --- ดัชนีอาร์เรย์เป้าหมาย+1 --- เริ่มตำแหน่งในอาร์เรย์เป้าหมาย <br> // ขนาด-ดัชนี --- จำนวนองค์ประกอบอาร์เรย์ที่จะคัดลอก ElementData [ดัชนี] = องค์ประกอบ; // ใส่องค์ประกอบที่จะเพิ่มที่ขนาดดัชนีอาร์เรย์ที่ระบุ ++; - โมฆะสาธารณะ ensurecapacity (int mincapacity) {modcount ++; int oldcapacity = elementData.length; // ความสามารถของอาร์เรย์ดั้งเดิมถ้า (mincapacity> oldcapacity) {Object OldData [] = ElementData; int newCapacity = (oldcapacity * 3)/2 + 1; // กำหนดความสามารถของอาร์เรย์ใหม่ซึ่งคือ 1.5 เท่าของความจุของอาร์เรย์ดั้งเดิม +1 ถ้า (newCapacity <mincapacity) newCapacity = mincapacity; // mincapacity มักจะใกล้เคียงกับขนาดดังนั้นนี่คือการชนะ: elementData = arrays.copyof (ElementData, newCapacity); // คัดลอกอาร์เรย์ที่ระบุและส่งคืนความจุของอาร์เรย์ใหม่เป็น newCapacity}} หากมีการเพิ่มองค์ประกอบมากกว่า 10 รายการในคอลเลกชันเลเยอร์ด้านล่างของ ArrayList จะสร้างอาร์เรย์ใหม่ที่มีความยาว 1.5 เท่า + 1 ของอาร์เรย์ดั้งเดิมและคัดลอกองค์ประกอบในอาร์เรย์ดั้งเดิมลงในอาร์เรย์ใหม่และองค์ประกอบเพิ่มเติมที่ตามมาจะถูกวางไว้ในอาร์เรย์ใหม่ กระบวนการนี้ซ้ำเมื่อความยาวของอาร์เรย์ใหม่ไม่สามารถรองรับองค์ประกอบที่เพิ่มใหม่ได้ นี่คือหลักการดำเนินการของการเพิ่มองค์ประกอบในคอลเลกชัน
3. รับวิธี:
1) รับ (INT ดัชนี) ส่งคืนองค์ประกอบที่ตำแหน่งที่ระบุในรายการนี้
สาธารณะ e get (int index) {rangecheck (ดัชนี); // ตรวจสอบว่าดัชนีที่ระบุที่ผ่านมาคือผลตอบแทนตามกฎหมาย (e) elementData [ดัชนี]; // ส่งคืนองค์ประกอบอาร์เรย์ด้วยดัชนีตัวห้อยอาร์เรย์} โมฆะส่วนตัว Rangecheck (ดัชนี int) {ถ้า (ดัชนี> = ขนาด) // ถ้าตัวห้อยที่เข้ามามากกว่าหรือเท่ากับความจุของชุด - 4. ลบวิธี:
1) E ลบ (INT ดัชนี) ลบองค์ประกอบที่ตำแหน่งที่ระบุในรายการนี้ ย้ายองค์ประกอบที่ตามมาทั้งหมดไปทางซ้าย (การลดลงของดัชนีโดย 1)
2) บูลีนลบ (วัตถุ o) ลบองค์ประกอบที่ระบุที่ปรากฏเป็นครั้งแรกในรายการนี้ (ถ้ามีอยู่) หากรายการไม่มีองค์ประกอบนี้รายการจะไม่เปลี่ยนแปลงและค่าบูลีนจะถูกส่งคืน
สาธารณะ e ลบ (int index) {rangecheck (ดัชนี); // ตรวจสอบว่าดัชนีที่ระบุเป็น ModCount ++ หรือไม่; e oldValue = (e) elementData [ดัชนี]; // รับองค์ประกอบอาร์เรย์ของดัชนีที่ระบุ int nummoved = size - ดัชนี - 1; // จำนวนองค์ประกอบที่จะย้ายถ้า (nummoved> 0) system.arraycopy (elementData, ดัชนี+1, elementData, ดัชนี, nummoved); // เลื่อนองค์ประกอบอาร์เรย์องค์ประกอบ [-ขนาด] = null; // ให้ GC ทำงานคืน OldValue; } บูลีนสาธารณะลบ (วัตถุ o) {ถ้า (o == null) {// ถ้าพารามิเตอร์ที่ผ่านเป็น null สำหรับ (int index = 0; index <size; index ++) ถ้า (ElementData [index] == null) {// ลบการเกิดครั้งแรกของ null fastremove (ดัชนี); กลับมาจริง; }} else {สำหรับ (int index = 0; index <size; index ++) ถ้า (o.equals (elementData [index])) {fastremove (ดัชนี); กลับมาจริง; }} return false; } โมฆะส่วนตัว fastremove (ดัชนี int) {// ลบองค์ประกอบที่ตำแหน่งที่ระบุวิธีการใช้งานคล้ายกับการลบ (int i) modcount ++; int nummoved = size - ดัชนี - 1; if (nummoved> 0) system.arraycopy (elementData, ดัชนี+1, elementData, ดัชนี, nummoved); ElementData [-size] = null; // ให้ GC ทำงาน} 5. วิธีการโคลน:
1) Object clone () ส่งคืนสำเนาตื้นของอินสแตนซ์ arraylist นี้ (ไม่มีการคัดลอกองค์ประกอบเหล่านี้เอง)
วัตถุสาธารณะโคลน () {ลอง {arraylist <e> v = (arraylist <e>) super.clone (); // การคำนวณวิธีการโคลนของคลาสวัตถุเพื่อส่งคืนวัตถุ ArrayList V.ElementData = array.CopyOf (ElementData, ขนาด); // คัดลอกอาร์เรย์เป้าหมาย v.modcount = 0; กลับ V; } catch (clonenotsupportedexception e) {// สิ่งนี้ไม่ควรเกิดขึ้นเนื่องจากเราได้โยน InternalError ใหม่ (); - การวิเคราะห์ข้างต้นของรหัสแหล่งสำคัญบางอย่างของ ArrayList เรารู้หลักการดำเนินการพื้นฐานของ ArrayList มีจุดและคะแนนต่อไปนี้สำหรับซอร์สโค้ด ArrayList:
1) เลเยอร์พื้นฐานของ ArrayList ถูกนำมาใช้ตามอาร์เรย์และองค์ประกอบเป้าหมายสามารถพบได้อย่างถูกต้องผ่านมาตรฐานต่อไปนี้ดังนั้นประสิทธิภาพการค้นหาจึงสูง อย่างไรก็ตามการเพิ่มหรือลบองค์ประกอบจะเกี่ยวข้องกับการเคลื่อนไหวของตำแหน่งขององค์ประกอบจำนวนมากซึ่งไม่มีประสิทธิภาพ
2) ArrayList ให้วิธีการก่อสร้างที่แตกต่างกันสามวิธี วิธีการก่อสร้างแบบไม่มีพารามิเตอร์สร้างอาร์เรย์ของประเภทวัตถุที่มีความยาว 10 โดยค่าเริ่มต้นที่ชั้นล่าง เมื่อจำนวนองค์ประกอบที่เพิ่มเข้ามาในชุดมากกว่า 10 อาร์เรย์จะขยายโดยอัตโนมัตินั่นคือสร้างอาร์เรย์ใหม่และวางองค์ประกอบของอาร์เรย์ดั้งเดิมลงในอาร์เรย์ใหม่
3) วิธีการ ensurecapacity ขยายอาร์เรย์ซึ่งจะสร้างอาร์เรย์ใหม่ที่มีความยาว 1.5 เท่า + 1 ของอาร์เรย์ดั้งเดิม เมื่อองค์ประกอบถูกเพิ่มเข้ากับ ArrayList อย่างต่อเนื่องให้ทำซ้ำกระบวนการเมื่อความยาวอาร์เรย์ไม่สามารถตอบสนองความต้องการได้
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น