1. การวิเคราะห์ซอร์สโค้ด ArrayList (JDK7)
ArrayList รักษาอาร์เรย์วัตถุแบบไดนามิกภายใน การเพิ่มแบบไดนามิกและการลบ ArrayList เป็นการเพิ่มแบบไดนามิกและการลบของกลุ่มคู่นี้
1. ArrayList Construction และ Initialization
ตัวแปรอินสแตนซ์ arrayList // arraylist ความจุเริ่มต้นส่วนตัวคงที่ int default_capacity = 10; // อาร์เรย์วัตถุเปล่าเริ่มต้นใช้เพื่อกำหนด ArrayListPrivate วัตถุสุดท้ายที่ว่างเปล่า [] emport_elementData = {}; // arraylist เก็บอาร์เรย์วัตถุarraylist constructor:
ไม่มีตัวสร้างพารามิเตอร์: นั่นคือสร้างวัตถุเปล่า []
Public ArrayList () {super (); this.elementData = emport_elementData;} ระบุขนาดกำลังการผลิต:
Public ArrayList (int initialcapacity) {super (); ถ้า (initialcapacity <0) โยน unlegalargumentException ใหม่ ("ความสามารถที่ผิดกฎหมาย:"+ initialcapacity); this.elementData = วัตถุใหม่ [initialCapacity];} ระบุโครงสร้างการรวบรวมที่ใช้อินเทอร์เฟซคอลเลกชัน:
Public ArrayList (คอลเลกชัน <? ขยาย e> c) {elementData = c.toArray (); size = elementData.length; // c.toarray อาจ (ไม่ถูกต้อง) ไม่ส่งคืนวัตถุ [] (ดู 6260652) ถ้า (ElementData.getClass ()! = Object []. class) ElementData = array.copyof (ElementData, ขนาด, วัตถุ []. คลาส);};สิ่งนี้ยังอธิบายถึงบทบาทของคอลเลกชันและเหตุผลที่ทำให้ Java-Collection-Framwork ออกแบบอินเทอร์เฟซคอลเลกชันแทนการใช้รายการ SET และอินเทอร์เฟซอื่น ๆ โดยตรง
2. กลไกการจัดสรรความสามารถของ ArrayList
ขีด จำกัด ขีดความสามารถสำหรับ ArrayList: ความจุ ArrayList คือขีด จำกัด สูงสุดและทฤษฎีอนุญาตให้มีการจัดสรรจำนวนเต็ม MAX_VALUE - ความจุ 8 ขนาด อย่างไรก็ตามสามารถจัดสรรได้เท่าใดขึ้นอยู่กับการตั้งค่าสแต็กและต้องตั้งค่าพารามิเตอร์ VM
int สุดท้ายคงที่ int max_array_size = integer.max_value - 8;
ขยายระดับเสียงเมื่อเรียกใช้วิธีเพิ่ม
บูลีนสาธารณะเพิ่ม (e e) {ensurecapacityInternal (ขนาด + 1); // เพิ่ม modcount !! ElementData [ขนาด ++] = E; กลับมาจริง; -วิธีการ ensureCapacityInternal (INT) กำหนดขนาดการขยายขั้นต่ำ
โมฆะส่วนตัว ensureCapacityInternal (int mincapacity) {ถ้า (elementData == emport_elementData) {mincapacity = math.max (default_capacity, mincapacity); } ensureeExplicitCapacity (mincapacity); } โมฆะส่วนตัว ensureexplicitCapacity (int mincapacity) {modcount ++; // รหัสที่ใส่ใจล้นถ้า (mincapacity - elementData.length> 0) เติบโต (mincapacity); - เกี่ยวกับ ModCount: ModCount ถูกกำหนดไว้ในคลาสนามธรรม AbstractList ความคิดเห็นของซอร์สโค้ดโดยทั่วไปอธิบายการใช้งาน: เมื่อใช้ตัววนซ้ำเพื่อสำรวจมันจะใช้เพื่อตรวจสอบว่าองค์ประกอบในรายการมีการเปลี่ยนแปลงโครงสร้างหรือไม่ (จำนวนจำนวนองค์ประกอบรายการมีการเปลี่ยนแปลง) ส่วนใหญ่จะใช้ในสภาพแวดล้อมแบบมัลติเธรดเพื่อป้องกันไม่ให้เธรดหนึ่งวนซ้ำและเธรดอื่นแก้ไขโครงสร้างของรายการนี้
วิธีการเติบโตเป็นวิธีการขยายตัวจริง
โมฆะส่วนตัว 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); -นอกจากนี้ยังมีวิธีการ hugecapacity สำหรับจำนวนกำลังการผลิต
ส่วนตัวคงที่ int hugecapacity (int mincapacity) {ถ้า (mincapacity <0) // overflow โยน outofMemoryError ใหม่ (); return (mincapacity> max_array_size)? Integer.max_value: max_array_size; - สรุป:
การขยายตัวแต่ละครั้งจะมาพร้อมกับสำเนาของอาร์เรย์ดังนั้นการให้กำลังการผลิตที่เหมาะสมในแต่ละครั้งจะปรับปรุงประสิทธิภาพเล็กน้อย
รูปต่อไปนี้คือกระบวนการขยายทั้งหมดที่ฉันสรุป:
3.ARRAYLIST ITERATOR
มีตัววนซ้ำหลักสองตัวของ ArrayList และ Listitr แต่มีการเพิ่ม ArrayListSpliterator ใน JDK1.8 มาเรียนรู้การวิเคราะห์ซอร์สโค้ดของ ITR และ listitr ตามลำดับ
(1) ITR: สามารถย้อนกลับได้เท่านั้น
คลาสส่วนตัว ITR ใช้ Iterator <E> {int Cursor; // ดัชนีขององค์ประกอบถัดไปเพื่อส่งคืน int lastret = -1; // ดัชนีขององค์ประกอบสุดท้ายที่ส่งคืน; -1 ถ้าไม่มี // ที่คาดหวังเช่นนั้นเป็นสำเนาของ ModCount int ที่คาดหวัง modCount = modCount; บูลีนสาธารณะ hasnext () {กลับเคอร์เซอร์! = ขนาด; } @suppresswarnings ("ไม่ได้ตรวจสอบ") สาธารณะ e ถัดไป () {checkForcomodification (); // บันทึกตำแหน่งปัจจุบัน int i = เคอร์เซอร์; if (i> = size) โยน nosuchelementException ใหม่ (); Object [] ElementData = ArrayList.his.ElementData; if (i> = elementData.length) โยนใหม่พร้อมกันใหม่ Exception (); // ตำแหน่งของเคอร์เซอร์องค์ประกอบถัดไป = i + 1; return (e) elementData [lastret = i]; } // ใช้วิธีการลบของตัววนซ้ำโมฆะสาธารณะลบ () {ถ้า (lastret <0) โยนใหม่ ungelStateException (); checkforcomodification (); ลอง {// สังเกตว่าชั้นเรียนภายในเรียก arraylist ชั้นนอกนี้อย่างไร. remove (Lastret); // หลังจากลบคุณจะต้องปรับตำแหน่งของเคอร์เซอร์ตัวชี้แต่ละครั้ง = Lastret; Lastret = -1; คาดว่า ModCount = ModCount; } catch (indexoutofboundsexception ex) {โยนใหม่พร้อมกันใหม่ Exception (); }} void สุดท้าย checkForComodification () {ถ้า (modcount! = คาดหวัง modcount) โยนใหม่พร้อมกัน modificationException (); - จากซอร์สโค้ดจะเห็นได้ว่าตัววนซ้ำ ITR เป็นตัววนซ้ำไปข้างหน้าซึ่งให้วิธีการต่อไปเพื่อรับองค์ประกอบใน ArrayList
CheckForComodification เป็นกลไกการตรวจจับข้อผิดพลาดที่ล้มเหลวอย่างรวดเร็วในงาน Java-Collection-Framwork การทำงานในชุดเดียวกันในสภาพแวดล้อมแบบมัลติเธรดอาจทำให้เกิดกลไกที่ล้มเหลวอย่างรวดเร็วและโยนข้อยกเว้นพร้อมกัน Exception พร้อมกัน
ITR Iterator กำหนดสำเนาของ Modcount Record ที่คาดไว้ เมื่อ ArrayList ดำเนินการเพื่อเปลี่ยนโครงสร้างเช่นเพิ่มลบและวิธีการที่ชัดเจนค่าของ ModCount จะเปลี่ยนไป
ผ่านซอร์สโค้ด ITR จะเห็นได้ว่าการเรียกใช้วิธีต่อไปและลบวิธีการจะทริกเกอร์การตรวจสอบที่ล้มเหลวอย่างรวดเร็ว ในเวลานี้หากมีข้อยกเว้นเกิดขึ้นเมื่อเธรดอื่นกำลังดำเนินการที่เปลี่ยนโครงสร้างที่ตั้งไว้ในขณะที่ข้ามชุด
(2) Listitr: สนับสนุนการสำรวจไปข้างหน้าและย้อนกลับ มาดูซอร์สโค้ดของ Listitr:
คลาสส่วนตัว listitr ขยาย ITR ใช้ listiterator <e> {listitr (ดัชนี int) {super (); เคอร์เซอร์ = ดัชนี; } บูลีนสาธารณะ hasprevious () {กลับเคอร์เซอร์! = 0; } public int nextindex () {กลับเคอร์เซอร์; } public int preventIndex () {กลับเคอร์เซอร์ - 1; } @suppresswarnings ("ไม่ได้ตรวจสอบ") สาธารณะก่อนหน้า () {checkForcomodification (); // ตำแหน่งขององค์ประกอบก่อนหน้าของ ArrayList int i = เคอร์เซอร์ - 1; ถ้า (i <0) โยน nosuchelementexception ใหม่ (); Object [] ElementData = ArrayList.his.ElementData; if (i> = elementData.length) โยนใหม่พร้อมกันใหม่ Exception (); เคอร์เซอร์ = i; return (e) elementData [lastret = i]; } // วิธีการตั้งค่าจะถูกเพิ่มเข้าไปในชุดโมฆะสาธารณะตัววนซ้ำ (E E) {ถ้า (Lastret <0) โยนใหม่ unlislStateException (); checkforcomodification (); ลอง {arraylist.his.set (Lastret, e); } catch (indexoutofboundsexception ex) {โยนใหม่พร้อมกันใหม่ Exception (); }} // ตัววนซ้ำนี้เพิ่มวิธีการเพิ่มโมฆะสาธารณะเพิ่ม (e e) {checkForcomodification (); ลอง {int i = เคอร์เซอร์; arraylist.his.add (i, e); // หมายเหตุเคอร์เซอร์ตำแหน่งตัวชี้ = i + 1; Lastret = -1; คาดว่า ModCount = ModCount; } catch (indexoutofboundsexception ex) {โยนใหม่พร้อมกันใหม่ Exception (); -การใช้งาน listitr นั้นเหมือนกับ ITR โดยทั่วไปการเพิ่มวิธีการที่สามารถข้ามได้ก่อนหน้านี้รวมถึงวิธีการเพิ่มและตั้งค่า
(3) ใช้ลิสต์ copyonwritearraylist ใน java.util.concurrent เพื่อแก้ปัญหา Fast-Fail
CopyOnWriteArrayList เป็นเธรดที่ปลอดภัย สำหรับรายละเอียดลองมาดูซอร์สโค้ดวิธีเพิ่มวิธี:
บูลีนสาธารณะเพิ่ม (e e) {สุดท้าย reentrantlock lock = this.lock; lock.lock (); ลอง {object [] องค์ประกอบ = getArray (); int len = elements.length; Object [] newElements = array.copyof (องค์ประกอบ, len + 1); newElements [len] = e; SetArray (newElements); กลับมาจริง; } ในที่สุด {lock.unlock (); - CopyonWriteArrayList เป็น arraylist ที่คัดลอกเมื่อเขียน เมื่อเริ่มต้นการทำงานของการเขียนข้อมูลอาร์เรย์ copyof เป็นอาร์เรย์ใหม่ซึ่งจะไม่ส่งผลกระทบต่อการดำเนินการอ่าน
ค่าใช้จ่ายนี้คือการสูญเสียหน่วยความจำและทำให้เกิดปัญหาด้านประสิทธิภาพ เมื่อเขียน CopiOnWriteArrayList วัตถุคัดลอกจะถูกสร้างขึ้นในหน่วยความจำและวัตถุต้นฉบับยังคงมีอยู่
CopyOnWriteArrayList ไม่สามารถรับประกันความสอดคล้องของข้อมูลแบบเรียลไทม์ได้สามารถรับประกันความสอดคล้องของผลลัพธ์เท่านั้น เหมาะสำหรับสถานการณ์เช่นแคชเมื่ออ่านมากขึ้นและเขียนมากขึ้นและเขียนน้อยลงในสถานการณ์ที่เกิดขึ้นพร้อมกัน
(4) วิธีการอื่น ๆ ซอร์สโค้ดของ ArrayList:
วิธีการส่วนตัว batchremove (คอลเลกชัน <?> c, บูลีนส่วนประกอบ) นั่นคือการดำเนินการกำจัดแบทช์
Batchremove บูลีนส่วนตัว (คอลเลกชัน <?> c, บูลีนส่วนประกอบ) {// เหตุผลในการใช้ขั้นสุดท้ายถูกกล่าวถึงด้านล่างวัตถุสุดท้าย [] elementData = this.elementData; int r = 0, w = 0; บูลีนดัดแปลง = false; ลอง {// ความเงียบสงบผ่านองค์ประกอบในรายการและตรวจสอบสำหรับ (; r <size; r ++) ถ้า (c.contains (elementData [r]) == ส่วนประกอบ) elementData [w ++] = elementData [r]; } ในที่สุด {// หากมีข้อยกเว้นเกิดขึ้นในการลองตรวจสอบความสอดคล้องของข้อมูลและดำเนินการคัดลอกต่อไปนี้หาก (r! = ขนาด) {system.arraycopy (ElementData, R, ElementData, W, Size - R); w += ขนาด - r; } // ทำความสะอาดองค์ประกอบที่ไม่ได้ใช้และแจ้งให้ GC รีไซเคิลถ้า (w! = ขนาด) {// ล้างเพื่อให้ GC ทำงานสำหรับ (int i = w; i <size; i ++) elementData [i] = null; modcount += size - w; ขนาด = W; แก้ไข = true; }} ส่งคืนแก้ไข; - ตัวแปรที่แก้ไขโดยสุดท้ายอ้างถึงการอ้างอิงเดียวกันเพื่อรักษาความสอดคล้องของข้อมูลในภายหลัง
ในวิธีนี้เมื่อคุณต้องการรักษาองค์ประกอบในคอลเลกชัน C ค่าการเติมเต็มจะเป็นจริง เมื่อคุณต้องการลบองค์ประกอบใน C ค่าส่วนประกอบเป็นเท็จ สิ่งนี้จะกลายเป็นวิธี Retainall และ RemoveAll ตามลำดับ
สลับ: แลกเปลี่ยนสองตำแหน่งใน ArrayList
2. การวิเคราะห์ซอร์สโค้ด LinkedList (JDK7)
LinkedList เป็นรายการที่เชื่อมโยง เมื่อเปรียบเทียบกับตารางการสั่งซื้อรายการที่เชื่อมโยงไม่จำเป็นต้องใช้หน่วยหน่วยความจำต่อเนื่องเพื่อจัดเก็บข้อมูล ลดปัญหาการเคลื่อนย้ายองค์ประกอบที่เกิดจากการปรับเปลี่ยนโครงสร้างคอนเทนเนอร์และการเข้าถึงแบบต่อเนื่องนั้นค่อนข้างมีประสิทธิภาพ
1. คำจำกัดความของโหนด
LinkedList ใน JDK เป็นรายการที่เชื่อมโยงแบบสองทิศทางแต่ละโหนดจะเก็บข้อมูลเกี่ยวกับโหนดก่อนหน้าและโหนดถัดไปตามลำดับ คำจำกัดความของมันมีดังนี้:
โหนดคลาสคงที่ระดับส่วนตัว <E> {E รายการ; โหนด <E> ถัดไป; โหนด <E> ก่อนหน้า; โหนด <E> (โหนด <E> ก่อนหน้า, องค์ประกอบ e, โหนด <E> ถัดไป) {this.item = องค์ประกอบ; this.next = ถัดไป; this.prev = prev; -2. การก่อสร้าง LinkedList และการเริ่มต้น
สมาชิก: 3 ตัวแปรสมาชิกจะถูกเก็บรักษาไว้ใน LinkedList เพื่อบันทึกจำนวนโหนดในรายการที่เชื่อมโยงผู้บุกเบิกและผู้สืบทอดของโหนด
ขนาด int ชั่วคราว = 0; โหนดชั่วคราว <e> ก่อน; โหนดชั่วคราว <e> ล่าสุด;
ตัวสร้าง: ตัวสร้างเริ่มต้นคือการสร้าง LinkedList ที่ว่างเปล่า
Public LinkedList () {}หรือสร้างขึ้นอยู่กับคอนเทนเนอร์อื่น ๆ และในภายหลังเราจะเขียนคอนสตรัคเตอร์เพื่อสร้างรายการลิงก์ที่สั่งซื้อ
Public LinkedList (คอลเลกชัน <? ขยาย e> c) {this (); addall (c);}นี่คือพิเศษเล็กน้อย สำหรับความแตกต่างระหว่างตัวดัดแปลงทั่วไป? Super T และขยาย T ดูบทความนี้เกี่ยวกับความแตกต่างระหว่าง Super T และขยาย T ใน Generics
3. การทำงานเชิงโครงสร้างของ LinkedList
วิธีการแทรกส่วนหัว: นั่นคือแทรกองค์ประกอบในส่วนหัวของรายการที่เชื่อมโยง
โมฆะส่วนตัว LinkFirst (e e) {โหนดสุดท้าย <e> f = แรก; โหนดสุดท้าย <e> newNode = โหนดใหม่ <> (null, e, f); First = newNode; // ตัดสินว่าเป็นรายการที่เชื่อมโยงเปล่าถ้า (f == null) last = newNode; อื่น f.prev = newNode; ขนาด ++; Modcount ++; - วิธีการแทรกหาง: นั่นคือแทรกองค์ประกอบที่ส่วนท้ายของรายการที่เชื่อมโยง
เป็นโมฆะ LinkLast (e e) {โหนดสุดท้าย <e> l = สุดท้าย; โหนดสุดท้าย <e> newNode = โหนดใหม่ <> (l, e, null); last = newNode; ถ้า (l == null) first = newNode; else l.next = newNode; ขนาด ++; Modcount ++; - ก่อนที่จะแทรกลงในโหนดปัจจุบัน: ค้นหาไดรฟ์ด้านหน้าของโหนดปัจจุบัน
เป็นโมฆะ linkbefore (e e, โหนด <e> succ) {// ตรวจสอบว่าโหนดไม่ว่างเปล่าของหลักสูตรสุดท้าย <e> pred = succ.prev; โหนดสุดท้าย <e> newNode = โหนดใหม่ <> (pred, e, succ); succ.prev = newNode; // ตรวจสอบว่าโหนดปัจจุบันเป็นโหนดแรกถ้า (pred == null) First = newNode; else pred.next = newNode; ขนาด ++; Modcount ++; - วิธีการลบส่วนหัว: ลบโหนดแรกของรายการที่เชื่อมโยง
ส่วนตัว e unlinkFirst (โหนด <E> f) {// ยืนยัน f == ครั้งแรก && f! = null; E Element e สุดท้าย = f.item; โหนดสุดท้าย <e> next = f.next; f.item = null; f.next = null; // ช่วย gc ก่อน = ถัดไป; if (next == null) last = null; nelem.prev = null; ขนาด--; Modcount ++; องค์ประกอบกลับ; - วิธีการลบหาง: ลบโหนดสุดท้ายของรายการที่เชื่อมโยง
ส่วนตัว e unlinklast (โหนด <e> l) {// ตรวจสอบให้แน่ใจว่า l == สุดท้ายและ l! = null final e Element = l.item; โหนดสุดท้าย <e> prev = l.prev; l.item = null; l.prev = null; // Help GC last = prev; if (prev == null) first = null; else prev.next = null; ขนาด--; Modcount ++; องค์ประกอบกลับ; -4. รักษาความสอดคล้องระหว่างอินเทอร์เฟซรายการและ deque
อินเทอร์เฟซรายการช่วยให้การใช้ตัวห้อยสามารถใช้การเข้าถึงแบบสุ่มไปยังคอนเทนเนอร์และง่ายต่อการใช้การเข้าถึงแบบสุ่มไปยังอาร์เรย์แบบนี้ สำหรับรายการที่เชื่อมโยง JDK ยังใช้จำนวนจำนวนโหนดในรายการที่เชื่อมโยงเพื่อให้การใช้งานการเข้าถึงแบบสุ่ม
โหนด <E> โหนด (ดัชนี int) {// ตรวจสอบความถูกต้องของดัชนีถ้า (ดัชนี <(ขนาด >> 1)) {node <e> x = ก่อน; สำหรับ (int i = 0; i <index; i ++) x = x.next; กลับ x; } else {node <e> x = สุดท้าย; สำหรับ (int i = size-1; i> index; i--) x = x.prev; กลับ x; - ดัชนีคือจำนวนครึ่งแรกค้นหาตั้งแต่ต้น ดัชนีเป็นของจำนวนครึ่งหลังและค้นหาจากจุดสิ้นสุด ใช้ประโยชน์อย่างเต็มที่จากคุณสมบัติของรายการที่เชื่อมโยงสองทาง
ดังนั้นเพิ่ม (INT INDEX, T T), รับ (int), set (int) และวิธีการอื่น ๆ สามารถนำไปใช้ได้อย่างง่ายดาย
LinkedList ใช้อินเทอร์เฟซ deque นั่นคือ LinkedList ใช้วิธีการของคอนเทนเนอร์คิวสองปลาย นี่คือบทสรุป API
5. LinkedList Traversal
เนื่องจาก LinkedList เป็นรายการที่เชื่อมโยงสองทางคุณจึงสามารถสำรวจมันไปมาได้ เช่นเดียวกับ ArrayList, LinkedList ยังมีปัญหาที่ล้มเหลวอย่างรวดเร็วเมื่อพูดถึงการทำงานแบบมัลติเธรดคอนเทนเนอร์
ปัญหาของ Fail-Fast ได้รับการอธิบายในบทความก่อนหน้านี้ดังนั้นฉันจะไม่พูดถึงเรื่องนี้ที่นี่
เกี่ยวกับตัววนซ้ำ LinkedList มีตัววนซ้ำแบบสองทิศทางของ Listiterator และตัววนซ้ำ DescendingIterator Inverse ทั้งหมดนั้นง่ายมาก ไม่ได้วิเคราะห์ซอร์สโค้ด
หากคุณสำรวจองค์ประกอบค่าใช้จ่ายในการเข้าถึงแบบสุ่มค่อนข้างสูง
3. LinkedList, ArrayList, Vector Summary
1. LinkedList และ ArrayList
ArrayList ใช้โครงสร้างข้อมูลตามอาร์เรย์แบบไดนามิกและ LinkedList ขึ้นอยู่กับโครงสร้างข้อมูลตามรายการที่เชื่อมโยง
สำหรับการเข้าถึงแบบสุ่มเพื่อรับและตั้งค่า ArrayList รู้สึกดีกว่า LinkedList เพราะ LinkedList ย้ายตัวชี้
สำหรับการดำเนินการใหม่และการลบเพิ่มและลบ LinedList มีข้อได้เปรียบที่ดีกว่าเพราะ ArrayList ต้องการย้ายข้อมูล ขึ้นอยู่กับสถานการณ์จริง หากมีการแทรกหรือลบข้อมูลชิ้นเดียวเพียงชิ้นเดียวความเร็วของ ArrayList จะดีกว่าของ LinkedList อย่างไรก็ตามหากข้อมูลถูกแทรกแบบสุ่มในแบทช์ความเร็วของ LinkedList นั้นดีกว่าของ ArrayList มาก เนื่องจากทุกครั้งที่มีการแทรกข้อมูล ArrayList จึงจำเป็นต้องย้ายจุดแทรกและข้อมูลทั้งหมดหลังจากนั้น
2. ArrayList และ Vector
เวกเตอร์เป็นเกลียวแบบซิงโครนัสดังนั้นจึงเป็นแบบเธรดที่ปลอดภัยในขณะที่ arraylist คือ Thread-asyn ซึ่งไม่ปลอดภัย หากปัจจัยด้านความปลอดภัยของด้ายไม่ได้นำมาพิจารณา ArrayList นั้นมีประสิทธิภาพมากกว่า
หากจำนวนองค์ประกอบในชุดมากกว่าความยาวของอาร์เรย์ชุดปัจจุบันอัตราการเติบโตของเวกเตอร์คือ 100% ของความยาวอาร์เรย์ปัจจุบันและอัตราการเติบโตของ Arraylist คือ 50% ของความยาวอาร์เรย์ปัจจุบัน หากใช้ข้อมูลที่มีข้อมูลจำนวนมากในชุดการใช้เวกเตอร์มีข้อดีบางประการ
หากคุณค้นหาข้อมูลในตำแหน่งที่ระบุเวลาที่เวกเตอร์และ ArrayList ใช้เหมือนกันทั้ง 0 (1) และคุณสามารถใช้เวกเตอร์และ ArrayList ในเวลานี้ หากเวลาที่ใช้ในการเคลื่อนย้ายข้อมูลในตำแหน่งที่ระบุคือ 0 (Ni) n ซึ่งเป็นความยาวทั้งหมดคุณควรพิจารณาใช้ LinkList เนื่องจากใช้เวลา 0 (1) ในการย้ายข้อมูลที่ตำแหน่งที่ระบุและเวลาที่ใช้ในการค้นหาข้อมูลในสถานที่ที่ระบุคือ 0 (i)
ArrayList และ Vector ใช้อาร์เรย์เพื่อจัดเก็บข้อมูล จำนวนองค์ประกอบในอาร์เรย์นี้มีขนาดใหญ่กว่าข้อมูลที่เก็บไว้จริงเพื่อเพิ่มและแทรกองค์ประกอบ ทั้งสองอนุญาตองค์ประกอบดัชนีหมายเลขซีเรียลโดยตรง อย่างไรก็ตามการแทรกข้อมูลจะต้องได้รับการออกแบบมาเพื่อย้ายองค์ประกอบอาร์เรย์และการทำงานของหน่วยความจำอื่น ๆ ดังนั้นข้อมูลดัชนีจึงรวดเร็วและช้าในการแทรกข้อมูล เวกเตอร์ใช้วิธีการซิงโครไนซ์ (เธรดปลอดภัย) ดังนั้นประสิทธิภาพจึงแย่กว่า ArrayList LinkedList ใช้รายการที่เชื่อมโยงแบบสองทิศทางเพื่อจัดเก็บข้อมูล ข้อมูลการจัดทำดัชนีตามหมายเลขซีเรียลต้องมีการเดินทางไปข้างหน้าหรือย้อนกลับ แต่เมื่อแทรกข้อมูลเฉพาะรายการด้านหน้าและด้านหลังของรายการนี้เท่านั้นที่จะบันทึกดังนั้นการแทรกหลายองศาจะเร็วขึ้น!