คลาส System.Collections.arrayList เป็นอาร์เรย์พิเศษ โดยการเพิ่มและลบองค์ประกอบความยาวของอาร์เรย์สามารถเปลี่ยนแปลงได้แบบไดนามิก
หนึ่ง. ข้อได้เปรียบ
1. สนับสนุนฟังก์ชั่นการเปลี่ยนขนาดอัตโนมัติ
2. การแทรกองค์ประกอบที่ยืดหยุ่น
3. การลบองค์ประกอบที่ยืดหยุ่น
สอง. ข้อ จำกัด
เมื่อเทียบกับอาร์เรย์ธรรมดาความเร็วจะแย่ลงเล็กน้อย
สาม. เพิ่มองค์ประกอบ
1. PublicVirtualIntadd (ObjectValue);
เพิ่มวัตถุไปยังจุดสิ้นสุดของ ArrayList
arraylist alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E");เนื้อหาคือ
abcde
2. PublicVirtualVoidInsert (Intindex, ObjectValue);
แทรกองค์ประกอบลงในดัชนีที่ระบุของ ArrayList
arraylist alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); Alist.insert (0, "aa");ผลที่ได้คือ
aaabcde
3. PublicVirtualVoidInserTrange (Intindex, ICOLLECTIONC);
แทรกองค์ประกอบในคอลเลกชันลงในดัชนีที่ระบุของ ArrayList
arraylist alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); ArrayList List2 = NewarrayList (); list2.add ("tt"); list2.add ("ttt"); Alist.insertrange (2, list2);ผลที่ได้คือ
abtttttcde
สี่. ลบ
1. PublicVirtualVoidRemove (ObjectObj);
ลบการจับคู่แรกของวัตถุเฉพาะออกจาก arraylist โปรดทราบว่ามันเป็นชิ้นแรก
arraylist alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); Alist.Remove ("A");ผลที่ได้คือ
BCDE
2. PublicVirtualVoidRemoveat (Intindex);
ลบองค์ประกอบที่ดัชนีที่ระบุของ ArrayList
Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); Alist.removeat (0);ผลที่ได้คือ
BCDE
3. PublicVirtualVoidRemoverange (Intindex, IntCount);
ลบองค์ประกอบต่าง ๆ ออกจาก ArrayList ดัชนีแสดงถึงดัชนีจำนวนการนับแสดงถึงจำนวนที่เริ่มต้นจากดัชนี
Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); Alist.removerange (1,3);ผลที่ได้คือ
คัดลอกรหัสดังนี้: AE
4. PublicVirtualVoidClear ();
ลบองค์ประกอบทั้งหมดออกจาก ArrayList
ห้า. เรียงลำดับ
1.PublicVirtualVoidSort ();
เรียงลำดับองค์ประกอบใน ArrayList หรือบางส่วนของมัน
ArrayListalist = NewarrayList (); Alist.add ("E"); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); DropDownList1.Datasource = Alist;ผลที่ได้คือ
EABCD
ArrayListalist = NewarrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); Alist.sort (); DropdownList1.Datasource = ALIST; // DropDownListDropDownList1; DropDownList1.Databind ();ผลที่ได้คือ
abcde
2.PublicVirtualVoidReverse ();
ย้อนกลับลำดับขององค์ประกอบใน ArrayList หรือเป็นส่วนหนึ่งของมัน
arraylistalist = newarraylist (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.reverse (); // reverse DropdownList1.Datasource = ALIST; // DropDownListDropDownList1; DropDownList1.Databind ();ผลที่ได้คือ
EDCBA
หก. หา
1.PublicVirtualIntIndexof (วัตถุ);
2.PublicVirtualIntIndexof (วัตถุ, int);
3.PublicVirtualIntIndexof (วัตถุ, int, int);
ส่งคืนดัชนีที่อิงกับศูนย์ของนัดแรกของ ArrayList หรือบางส่วนของมัน ไม่พบผลตอบแทน -1
arraylist alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); intNindex = alist.indexof ("a"); // 1 nindex = Alist.indexof ("P"); // ไม่พบ -1 4.PublicVirtualIntLastIndexof (วัตถุ);
5. PublicVirtualIntLastIndexof (วัตถุ, int);
6.PublicVirtualIntLastIndexof (วัตถุ, int, int);
ส่งคืนดัชนีที่อิงกับศูนย์ของนัดสุดท้ายของ ArrayList หรือบางส่วนของมัน
arraylist alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("A"); // เหมือนกับ 0 Alist.add ("D"); Alist.add ("E"); intNindex = Alist.AlastIndexof ("A"); // ค่าคือ 2 แทน 0 7.PublicVirtualBoolContains (ObjectItem);
กำหนดว่าองค์ประกอบอยู่ใน ArrayList หรือไม่ ส่งคืนจริงถ้ารวมมิฉะนั้นจะส่งคืน FALSE
เจ็ด. อื่น
1. PublicVirtualIntcapacity {get; set;}
รับหรือตั้งค่าจำนวนองค์ประกอบที่ ArrayList สามารถมีได้
2. PublicVirtualIntCount {get;}
ได้รับจำนวนองค์ประกอบที่มีอยู่ใน ArrayList
ความจุคือจำนวนองค์ประกอบที่ ArrayList สามารถจัดเก็บได้ Count คือจำนวนองค์ประกอบที่มีอยู่ใน ArrayList ความจุมากกว่าหรือเท่ากับการนับเสมอ หากการนับเกินความสามารถเมื่อเพิ่มองค์ประกอบความจุของรายการจะเพิ่มขึ้นเป็นสองเท่าโดยการจัดวางอาร์เรย์ภายในโดยอัตโนมัติ
หากมีการตั้งค่าความจุอย่างชัดเจนอาร์เรย์ภายในจะต้องได้รับการกำหนดใหม่เพื่อรองรับความสามารถที่ระบุ หากความจุถูกตั้งค่าเป็น 0 อย่างชัดเจนรันไทม์ภาษาทั่วไปจะตั้งค่าเป็นความจุเริ่มต้น ความจุเริ่มต้นคือ 16
หลังจากโทรไปที่ Clear Count คือ 0 และในเวลานี้การลดความจุคือความจุเริ่มต้นที่ 16 ไม่ใช่ 0
3. PublicVirtualVoidTrimtosize ();
ตั้งค่าความจุเป็นจำนวนองค์ประกอบจริงใน ArrayList
หากคุณไม่ได้เพิ่มองค์ประกอบใหม่ในรายการวิธีนี้สามารถใช้เพื่อลดค่าใช้จ่ายของระบบหน่วยความจำของรายการ
หากต้องการล้างองค์ประกอบทั้งหมดในรายการอย่างสมบูรณ์ให้เรียกใช้วิธีการที่ชัดเจนก่อนที่จะเรียก trimtosize การตัด ArrayList ที่ว่างเปล่าจะตั้งค่าความจุของ ArrayList ให้เป็นความจุเริ่มต้นไม่ใช่ศูนย์
arraylist alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); 8. การวิเคราะห์รหัสที่มา
คลาสการใช้งานของอินเทอร์เฟซรายการภายในใช้อาร์เรย์เพื่อจัดเก็บค่าองค์ประกอบซึ่งเทียบเท่ากับอาร์เรย์ที่มีขนาดตัวแปร
1. ลายเซ็น
arraylist คลาสสาธารณะ <e> ขยายบทคัดย่อ <e> ใช้รายการ <e>, RandomAccess, cloneable, serializable
คุณจะเห็นว่า ArrayList สืบทอดคลาสนามธรรมนามธรรมซึ่งใช้วิธีการส่วนใหญ่ของอินเตอร์เฟสรายการ หากคุณต้องการใช้รายการที่ไม่เปลี่ยนรูปเพียงแค่สืบทอดคลาสนี้และใช้วิธีการรับ (int) และขนาด หากคุณต้องการใช้รายการที่ไม่แน่นอนคุณต้องแทนที่ชุด (int, e) นอกจากนี้หากขนาดของรายการเป็นตัวแปรต้องใช้วิธีการเพิ่ม (int, e) และลบ () ()
2. ตัวสร้าง
ArrayList ให้สามตัวสร้าง:
arraylist () arraylist (คอลเลกชัน <? ขยาย e> c) arrayList (int initialcapacity)
การประชุมอินเทอร์เฟซคอลเลกชันที่แต่ละคลาสคอลเลกชันควรจัดให้มีตัวสร้าง "มาตรฐาน" สองตัวหนึ่งคือตัวสร้างที่ไม่มีพารามิเตอร์ (อันแรกด้านบน) และอีกอันคือตัวสร้างที่มีพารามิเตอร์เดียว (อันที่สองด้านบน) ArrayList ยังมีตัวสร้างที่สามที่ยอมรับค่า int เพื่อตั้งค่าขนาดเริ่มต้นของ Arrayli (ขนาดเริ่มต้นคือ 10)
3. วิธีการที่เกี่ยวข้อง
trimtosizepublic เป็นโมฆะ trimtosize () {modcount ++; int oldcapacity = elementData.length; if (size <oldcapacity) {elementData = array.copyof (elementData, ขนาด); -ใช้เพื่อลดความจุของ ArrayList ให้เป็นขนาดจริงในปัจจุบันและลดความสามารถในการจัดเก็บ ตัวแปร modcount นั้นสืบทอดมาจาก AbstractList โดยบันทึกจำนวนครั้งที่รายการได้รับการแก้ไขโครงสร้าง องค์ประกอบของ ArrayList นั้นถูกเก็บไว้ใน ElementData ซึ่งประกาศว่าเป็น: วัตถุชั่วคราวส่วนตัว [] ElementData; ขนาดตัวแปรคือจำนวนองค์ประกอบของ ArrayList เมื่อขนาด <oldcapacity โทรไปที่อาร์เรย์วิธีการใช้วิธีการลดลง
4.indexof และ lasindexof
ดัชนี int สาธารณะ (Object O) {ถ้า (o == null) {สำหรับ (int i = 0; i <size; i ++) ถ้า (elementData [i] == null) return i; } else {สำหรับ (int i = 0; i <size; i ++) ถ้า (o.equals (elementData [i])) กลับ i; } return -1; -สองวิธีนี้ส่งคืนตัวห้อยขององค์ประกอบที่ระบุและเราต้องการแยกแยะว่าพารามิเตอร์เป็นโมฆะหรือไม่ LastIndexof นั้นคล้ายคลึงกับ INDEXOF แต่การค้นหาจากด้านหลังสู่ด้านหน้า
5. ensurecapacity
โมฆะสาธารณะ ensurecapacity (int mincapacity) {ถ้า (mincapacity> 0) enurecapacityinternal (mincapacity); } โมฆะส่วนตัว ensureCapacityInternal (int mincapacity) {modcount ++; // รหัสที่ใส่ใจล้นถ้า (mincapacity - elementData.length> 0) เติบโต (mincapacity); } โมฆะส่วนตัว Grow (int mincapacity) {// รหัสผ่านไหลล้น int oldcapacity = elementData.length; int newCapacity = oldCapacity + (oldcapacity >> 1); if (newCapacity - mincapacity <0) newCapacity = mincapacity; if (newCapacity - max_array_size> 0) newcapacity = hugecapacity (mincapacity); // mincapacity มักจะใกล้เคียงกับขนาดดังนั้นนี่คือการชนะ: elementData = arrays.copyof (ElementData, newCapacity); -วิธีนี้ช่วยให้มั่นใจได้ว่าขนาดของ ArrayList
6.Add และ Addall
โมฆะสาธารณะเพิ่ม (ดัชนี int, องค์ประกอบ e) {rangecheckforadd (ดัชนี); ensurecapacityInternal (ขนาด + 1); // เพิ่ม modcount !! System.arrayCopy (ElementData, INDEX, ElementData, ดัชนี + 1, ขนาด - ดัชนี); ElementData [ดัชนี] = องค์ประกอบ; ขนาด ++; - เพิ่ม (INT ดัชนี, องค์ประกอบ e) เพื่อเพิ่มองค์ประกอบในตำแหน่งที่ระบุ ก่อนอื่นให้โทรหา RangeCheckForadd เพื่อตรวจสอบว่าดัชนีนั้นถูกต้องหรือไม่ ถ้าดัชนี> ขนาด || ดัชนี <0, ข้อยกเว้นจะถูกโยนทิ้ง จากนั้นตรวจสอบให้แน่ใจว่ากำลังการผลิตเพิ่มขึ้น 1 และระบบการโทรอาร์เรย์โคปีเพื่อย้ายองค์ประกอบที่เริ่มต้นจากดัชนีตำแหน่งหนึ่งไปข้างหลัง สุดท้ายตั้งค่าที่ดัชนีเป็นองค์ประกอบที่เพิ่มเข้ามา นอกจากนี้ยังมีวิธีการเพิ่มมากเกินไป (E E) ที่เพิ่มองค์ประกอบโดยตรงไปยังจุดสิ้นสุด
Addall (คอลเลกชัน <? ขยาย e> c) และ addall (ดัชนี int, คอลเลกชัน <? ขยาย e> c) เพิ่มองค์ประกอบทั้งหมดในการรวบรวมไปยังจุดสิ้นสุดและตำแหน่งที่ระบุตามลำดับ
7. ลบและลบออก
บูลีนสาธารณะลบ (วัตถุ o) {ถ้า (o == null) {สำหรับ (int index = 0; index <size; index ++) ถ้า (elementData [index] == null) {fastremove (ดัชนี); กลับมาจริง; }} else {สำหรับ (int index = 0; index <size; index ++) ถ้า (o.equals (elementData [index])) {fastremove (ดัชนี); กลับมาจริง; }} return false; -วิธีการลบ (วัตถุ O) ลบองค์ประกอบที่ระบุ ก่อนอื่นให้มองหาตำแหน่งองค์ประกอบจากนั้นโทรหา Fastremove (ดัชนี) เพื่อลบออก รหัสมีดังนี้:
โมฆะส่วนตัว fastremove (ดัชนี int) {modcount ++; int nummoved = size - ดัชนี - 1; if (nummoved> 0) // ย้ายองค์ประกอบทั้งหมดที่อยู่เบื้องหลังดัชนี+1 หนึ่งตำแหน่งไปข้างหน้า system.arrayCopy (ElementData, INDEX+1, ElementData, INDEX, NUMMOVED); ElementData [-size] = null; // ให้ GC ทำงาน} วิธีการลบ (ดัชนี int) overloaded ใช้เพื่อลบองค์ประกอบที่ตำแหน่งที่ระบุ Removerange (Int FromIndex, Int ToIndex) ใช้เพื่อลบองค์ประกอบทั้งหมดระหว่างตำแหน่งที่ระบุ
RemoveAll (คอลเลกชัน <?> c) และ retainall (คอลเลกชัน <?> c) รหัสมีดังนี้:
บูลีนสาธารณะ RemoveAll (คอลเลกชัน <?> c) {objects.requirenonnull (c); กลับ BatchRemove (C, FALSE); } บูลีนสาธารณะ retainall (คอลเลกชัน <?> c) {objects.requirenonnull (c); กลับ batchremove (c, true); -พวกเขาทั้งหมดถูกนำไปใช้โดยการเรียกวิธี Batchremove และรหัสของพวกเขามีดังนี้:
BatchRemove บูลีนส่วนตัว (คอลเลกชัน <?> C, บูลีนส่วนประกอบ) {วัตถุสุดท้าย [] elementData = this.elementData; int r = 0, w = 0; บูลีนดัดแปลง = false; ลอง {สำหรับ (; r <size; r ++) ถ้า (c.contains (elementData [r]) == ส่วนประกอบ) elementData [w ++] = elementData [r]; } ในที่สุด {// รักษาความเข้ากันได้ของพฤติกรรมกับ AbstractCollection, // แม้ว่า C.Contains () จะโยน if (r! = size) {system.arraycopy (elementData, r, elementData, w, size - r); w += ขนาด - r; } if (w! = ขนาด) {// ล้างเพื่อให้ GC ทำงานสำหรับ (int i = w; i <size; i ++) elementData [i] = null; modcount += size - w; ขนาด = W; แก้ไข = true; }} ส่งคืนแก้ไข; -วิธีนี้มีพารามิเตอร์สองตัว อย่างแรกคือคอลเลกชันการดำเนินการและที่สองคือค่าบูลีน โดยการตั้งค่าเป็นจริงหรือเท็จจะเลือกว่าจะลบหรือเก็บรักษาไว้ คำแถลงในการลองทำให้ส่วนที่เหลืออยู่ระหว่าง 0 ถึง W จากนั้นในที่สุดก็เป็นวินาทีถ้าในที่สุดในที่สุดก็จัดการกับพื้นที่หลังจาก W และอันแรกจะถูกดำเนินการเมื่อ C.Contains () โยนข้อยกเว้น