สิ่งที่พวกเขาอาจถามในการสัมภาษณ์: โครงสร้างข้อมูลใน Java ส่วนที่ 2

ตอนที่ 1 ตอนนี้เรากำลังพูดถึงพื้นฐานที่ Java Developer ทุกคนควรรู้ เกี่ยวกับความรู้คลาสสิกที่เป็นจุดเริ่มต้นของทุกสิ่ง วันนี้ฉันอยากจะพูดถึงหนึ่งในหัวข้อพื้นฐานของการสัมภาษณ์ - โครงสร้างข้อมูลใน Java ดังนั้น แทนที่จะไปยุ่งวุ่นวาย เรามาเริ่มกันเลยดีกว่า ติดตามความต่อเนื่องของรายการคำถามที่คุณอาจถูกถามในหัวข้อนี้ในระหว่างการสัมภาษณ์

6. บอกเราเกี่ยวกับรายการ

รายการคืออินเทอร์เฟซที่แสดงโครงสร้างที่เรียงลำดับของวัตถุ ซึ่งเรียกว่ารายการ “เคล็ดลับ” ของโครงสร้าง นี้คือองค์ประกอบที่มีอยู่ในListสามารถแทรก แก้ไข หรือลบได้โดยดัชนี ซึ่งก็คือ ตัวระบุภายในของList กล่าวอีกนัยหนึ่งดัชนีหมายถึง: "มีองค์ประกอบกี่รายการตั้งแต่เริ่มต้นรายการ" องค์ประกอบรายการ แรก มีดัชนี 0 องค์ประกอบที่สองมีดัชนี 1 และอื่นๆ องค์ประกอบที่ห้าจึงอยู่ห่างจากจุดเริ่มต้นของรายการสี่องค์ประกอบ ตามที่กล่าวไว้ข้างต้น ลำดับในการเพิ่มรายการลงในรายการมีความสำคัญ นั่นเป็นเหตุผลที่โครงสร้างข้อมูลถูกเรียกว่ารายการ เราแสดงรายการวิธีการเฉพาะสำหรับโครงสร้างนี้ซึ่งมุ่งเป้าไปที่การทำงานกับองค์ประกอบตามดัชนี:

• รับ - ส่งคืนองค์ประกอบในตำแหน่งที่ระบุ (ตามค่าดัชนี)
• ลบ - ลบองค์ประกอบในตำแหน่งที่ระบุ
• set - แทนที่องค์ประกอบในตำแหน่งที่ระบุด้วยองค์ประกอบที่ระบุในวิธีการ

การใช้งานหลักคือArrayListและLinkedList เราจะพูดถึงพวกเขาเพิ่มเติมในภายหลัง Vectorเป็นรายการที่ปลอดภัยต่อเธรด ดังนั้นแต่ละวิธีในคลาสนี้จึงซิงโครไนซ์กัน แต่โปรดจำไว้ว่าหากคุณต้องการรักษาความปลอดภัยของการดำเนินการบางอย่างในรายการ คุณจะต้องซิงโครไนซ์ลำดับการดำเนินการทั้งหมด และการซิงโครไนซ์การดำเนินการแต่ละรายการนั้นมีความปลอดภัยน้อยกว่าและช้ากว่ามาก แน่นอนว่าVectorยังมีค่าใช้จ่ายในการล็อค แม้ว่าคุณจะไม่ต้องการล็อคก็ตาม ดังนั้นคลาสนี้จึงถือว่าล้าสมัยและไม่ได้ใช้งาน โดยวิธีการ: ArrayListคล้ายกับVectorแต่ไม่ได้ใช้การล็อคดังนั้นจึงใช้ได้ทุกที่ Stackเป็นคลาสย่อยของ คลาส Vectorโดยมี Constructor เริ่มต้นหนึ่งตัวและวิธีการทั้งหมดของ คลาส Vectorบวกกับคลาสย่อยของตัวเองด้วย (เราจะพูดถึงพวกมันในภายหลัง) ตามตัวอย่าง คุณสามารถจินตนาการถึงกระบวนการนี้เป็นสแต็กของโฟลเดอร์ที่มีเอกสาร คุณวางโฟลเดอร์หนึ่งไว้ที่ด้านบนสุดของสแต็ก และคุณสามารถใช้โฟลเดอร์เหล่านี้ในลำดับย้อนกลับเท่านั้น โดยเริ่มจากด้านบน จริงๆ แล้วนี่คือ กลไกแบบ LIFOคือLast In First Outอันสุดท้ายที่ตามมาคืออันแรกที่ออก สแต็กใช้วิธีการของตัวเอง:

• push - เพิ่มองค์ประกอบที่ส่งผ่านไปยังด้านบนของสแต็ก
• peek - ส่งคืนองค์ประกอบที่อยู่ด้านบนของสแต็ก
• pop - ส่งคืนองค์ประกอบที่อยู่ด้านบนของสแต็กด้วย แต่จะลบออก
• ว่างเปล่า - ตรวจสอบว่าสแต็กว่างเปล่า - จริงหรือไม่ - เท็จ ;
• ค้นหา - ค้นหาสแต็กสำหรับองค์ประกอบที่กำหนด หากพบองค์ประกอบ หมายเลขลำดับที่สัมพันธ์กับด้านบนของสแต็กจะถูกส่งกลับ หากไม่พบองค์ประกอบ ค่าจะถูกส่งกลับ -1

ในขณะนี้ คลาสย่อย Stackไม่ได้ถูกใช้จริง ๆ เนื่องจากความเรียบง่ายและไม่ยืดหยุ่น แต่ถึงกระนั้น คุณอาจพบคลาสย่อยดังกล่าว ตัวอย่างเช่น เมื่อคุณได้รับข้อผิดพลาดและในคอนโซล คุณจะเห็นกลุ่มข้อความเกี่ยวกับข้อผิดพลาดดังกล่าว คุณสามารถอ่านเพิ่มเติมเกี่ยวกับสแต็ กและคิวได้ในบทความนี้

7. บอกเราเกี่ยวกับแผนที่

ตามที่ระบุไว้ข้างต้นแผนที่คือคอลเลกชันที่มีโครงสร้างแยกต่างหากของอินเทอร์เฟซและการใช้งาน แยกจากกันเพราะที่นี่ค่าจะไม่ถูกจัดเก็บทีละค่า แต่อยู่ในคู่ "คีย์-ค่า" วิธีการทำ แผนที่พื้นฐาน:

• ใส่(คีย์ K, ค่า V) - การเพิ่มองค์ประกอบลงในแผนที่;
• รับ(คีย์วัตถุ) - ค้นหาค่าด้วยคีย์
• containsKey(คีย์วัตถุ) - ตรวจสอบแผนที่ว่ามีคีย์นี้อยู่หรือไม่
• containsValue(ค่าอ็อบเจ็กต์) - ตรวจสอบแผนที่ว่ามีค่านี้อยู่หรือไม่
• ลบ(คีย์วัตถุ) - ลบค่าด้วยคีย์

อย่างที่คุณเห็น การดำเนินการส่วนใหญ่ทำงานโดยใช้คีย์ ตามกฎแล้ว วัตถุที่ไม่เปลี่ยนรูปจะถูกเลือกเป็นคีย์ ตัวอย่างทั่วไปของวัตถุนี้คือString การใช้งาน แผนที่ขั้นพื้นฐาน:

1. HashMap - ออกแบบมาเพื่อจัดเก็บค่าตามลำดับแบบสุ่ม แต่ช่วยให้คุณค้นหาองค์ประกอบแผนที่ได้อย่างรวดเร็ว ช่วยให้คุณสามารถระบุคีย์โดยใช้ คีย์เวิร์ดnull ได้แต่ต้องไม่เกินหนึ่งครั้ง เนื่องจาก คู่กับคีย์เดียวกันจะถูกเขียนทับกัน เงื่อนไขหลักคือเอกลักษณ์ของคีย์: ค่าสามารถทำซ้ำได้ (อาจมีค่า Null หลายค่า)
2. LinkedHashMapเป็นอะนาล็อกของ HashMapที่เก็บค่าตามลำดับที่เพิ่ม ดังนั้น เช่นเดียวกับLinkedListก็มีส่วนหัว - ส่วนหัวของรายการที่เชื่อมโยงแบบทวีคูณ เมื่อเริ่มต้น มันจะชี้ไปที่ตัวมันเอง

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

3. TreeMapเป็นแผนที่ที่จัดเรียงองค์ประกอบตามค่าคีย์ คล้ายกับTreeSetแต่สำหรับคู่ที่ยึดตามค่าคีย์ ในการตั้ง ค่ากฎการเรียงลำดับ TreeMapคีย์ต้องใช้อินเทอร์เฟซที่เปรียบเทียบได้ มิฉะนั้น ควรมี Key-Orient Comparator (อันที่ระบุไว้ในTreeMap Constructor ), TreeSet - นำไปใช้กับอ็อบเจ็กต์ TreeMap ภายใน ซึ่งในความเป็นจริงแล้ว ความมหัศจรรย์ทั้งหมดเกิดขึ้น

   คุณสามารถอ่านเพิ่มเติมเกี่ยวกับการเรียงลำดับใน TreeMap โดยใช้ต้นไม้สีแดงดำได้ในบทความเกี่ยวกับคุณสมบัติของ TreeMap

4. Hashtableคล้ายกับHashMapแต่ไม่อนุญาต ให้เก็บ ค่าว่างเป็นคีย์หรือค่า มีการซิงโครไนซ์อย่างระมัดระวังจากมุมมองแบบมัลติเธรด ซึ่งหมายความว่าปลอดภัยจากมุมมองแบบมัลติเธรด แต่การใช้งานนี้ล้าสมัยและช้า ดังนั้นตอนนี้คุณจะไม่เห็นHashtableในโปรเจ็กต์ใหม่ไม่มากก็น้อย

8. ArrayList กับ LinkedList อันไหนดีกว่าที่จะใช้?

คำถามนี้อาจเป็นคำถามที่ได้รับความนิยมมากที่สุดในโครงสร้างข้อมูลและมีข้อผิดพลาดบางประการด้วย ก่อนที่จะตอบคำถาม มาเรียนรู้เพิ่มเติมเกี่ยวกับโครงสร้างข้อมูลเหล่านี้ก่อน ArrayListใช้ อินเทอร์เฟซ รายการและดำเนินการกับอาร์เรย์ภายในที่ขยายตามความจำเป็น เมื่ออาร์เรย์ภายในเต็มไปหมด และจำเป็นต้องแทรกองค์ประกอบใหม่ อาร์เรย์ใหม่จะถูกสร้างขึ้นโดยมีขนาด (oldSize * 1.5) +1 หลังจากนี้ ข้อมูลทั้งหมดจากอาร์เรย์เก่าจะถูกคัดลอกไปยังองค์ประกอบใหม่ + ใหม่ และตัวรวบรวมขยะเก่าจะถูกลบ วิธีการเพิ่มจะเพิ่มองค์ประกอบลงในเซลล์ว่างสุดท้ายของอาร์เรย์ นั่นคือถ้าเรามี 3 องค์ประกอบอยู่แล้ว มันจะเพิ่มองค์ประกอบถัดไปในเซลล์ที่ 4 มาดูประสิทธิภาพของวิธีการพื้นฐานกัน:

• get(int index) - การรับองค์ประกอบในอาร์เรย์ด้วยดัชนีนั้นเร็วที่สุดในO(1) ;
• เพิ่ม(Object obj) - หากมีพื้นที่เพียงพอในอาร์เรย์ภายในสำหรับองค์ประกอบใหม่ จากนั้นจะใช้เวลาในการแทรกO(1) ปกติ เนื่องจากการเพิ่มถูกกำหนดเป้าหมายไปที่เซลล์สุดท้าย

  หากเราจำเป็นต้องสร้างอาร์เรย์ใหม่และคัดลอกเนื้อหาลงไป เวลาของเราจะเป็นสัดส่วนโดยตรงกับจำนวนองค์ประกอบในอาร์เรย์O(n) ;

• ลบ(ดัชนี int) - เมื่อลบองค์ประกอบเช่นจากตรงกลางเราจะได้เวลา O(n/2) เนื่องจากเราจะต้องย้ายองค์ประกอบไปทางขวาของมันกลับไปหนึ่งเซลล์ ดังนั้นหากลบจากจุดเริ่มต้นของรายการ O(n) จากจุดสิ้นสุด - O(1);
• add(int index, Object obj) - สถานการณ์คล้ายกับการลบ: เมื่อเพิ่มตรงกลาง เราจะต้องย้ายองค์ประกอบทางขวาหนึ่งเซลล์ไปข้างหน้า ดังนั้นเวลาจึงเป็น O(n/2) แน่นอนตั้งแต่ต้น - O(n) จากจุดสิ้นสุด - O(1);
• set(int index, Object obj) - ที่นี่สถานการณ์แตกต่างออกไป เนื่องจากคุณเพียงแค่ต้องค้นหาองค์ประกอบที่ต้องการและเขียนทับมันโดยไม่ย้ายส่วนที่เหลือ ดังนั้น O(1)

อ่านเพิ่มเติมเกี่ยวกับArrayListในบทความ นี้ LinkedListใช้สองอินเทอร์เฟซพร้อมกัน - ListและQueueดังนั้นจึงมีคุณสมบัติและเมธอดที่มีอยู่ในโครงสร้างข้อมูลทั้งสอง จากรายการเขาเข้าถึงองค์ประกอบตามดัชนีจากคิว - การมีอยู่ของ "หัว" และ "หาง" ภายในจะถูกนำไปใช้เป็นโครงสร้างข้อมูลที่แสดงรายการที่มีการเชื่อมโยงแบบทวีคูณ นั่นคือแต่ละองค์ประกอบมีลิงก์ไปยังองค์ประกอบถัดไปและก่อนหน้า ยกเว้น "หาง" และ "หัว"

• get(int index) - เมื่อค้นหาองค์ประกอบที่อยู่ตรงกลางรายการจะเริ่มค้นหาองค์ประกอบทั้งหมดตามลำดับจนกว่าจะพบองค์ประกอบที่ต้องการ ตามหลักเหตุผลแล้ว การค้นหาควรใช้O(n/2)แต่ LinkedList ก็มีส่วนท้ายด้วย ดังนั้นการค้นหาจึงดำเนินการพร้อมกันจากทั้งสองฝ่าย ดังนั้น เวลาจึงลดลงเหลือO(n/4 )

  ถ้าองค์ประกอบนั้นอยู่ใกล้กับจุดเริ่มต้นของรายการหรือจุดสิ้นสุด เวลาจะเป็นO(1) ;

• เพิ่ม(Object obj) - เมื่อเพิ่มองค์ประกอบใหม่ องค์ประกอบ "tail" จะมีลิงก์ไปยังองค์ประกอบถัดไปที่เพิ่มเข้ามา และองค์ประกอบใหม่จะได้รับลิงก์ไปยังองค์ประกอบก่อนหน้านี้และกลายเป็น "ส่วนท้าย" ใหม่ ดังนั้นเวลาจะเป็นO(1) ;
• ลบ(ดัชนี int) - ตรรกะคล้ายกับ เมธอด get(int index ) หากต้องการลบองค์ประกอบออกจากตรงกลางรายการ คุณต้องค้นหาองค์ประกอบนั้นก่อน นี่เป็นอีกครั้งO(n/4)ในขณะที่การลบนั้นไม่ได้ทำอะไรเลยจริง ๆ เนื่องจากมันจะเปลี่ยนเพียงตัวชี้ของวัตถุที่อยู่ใกล้เคียงเท่านั้น (พวกมันเริ่มอ้างถึงกันและกัน) หากองค์ประกอบอยู่ที่จุดเริ่มต้นหรือจุดสิ้นสุด ให้อีกครั้ง - O(1) ;
• add(int index, Object obj)และset(int index, Object obj) - วิธีการจะมีความซับซ้อนของเวลาเหมือนกับget(int index)เนื่องจากใช้เวลาส่วนใหญ่ในการค้นหาองค์ประกอบ ดังนั้นสำหรับตรงกลางรายการ - O(n/4)สำหรับจุดเริ่มต้น - O(1)

ข้อมูลเพิ่มเติมเกี่ยวกับการทำงานกับLinkedList อธิบายไว้ในบทความนี้ ลองดูทั้งหมดนี้ในตาราง: ดังที่คุณคงเข้าใจแล้ว เป็นไปไม่ได้ที่จะตอบคำถามนี้อย่างไม่คลุมเครือ ท้ายที่สุดแล้ว ในสถานการณ์ที่แตกต่างกัน พวกเขาทำงานด้วยความเร็วที่แตกต่างกัน ดังนั้นเมื่อถูกถามคำถามเช่นนี้ คุณควรถามทันทีว่ารายการนี้เน้นไปที่อะไร และจะดำเนินการใดบ่อยที่สุด เริ่มจากนี้ให้คำตอบแต่มีคำอธิบายว่าทำไมถึงเป็นเช่นนั้น มาสรุปการเปรียบเทียบของเรากัน: ArrayList:

• ตัวเลือกที่ดีที่สุดหากการดำเนินการบ่อยที่สุดคือการค้นหาองค์ประกอบโดยการเขียนทับองค์ประกอบ
• ทางเลือกที่แย่ที่สุดหากการดำเนินการเป็นการแทรกและการลบที่จุดเริ่มต้น-ตรงกลาง เนื่องจากการดำเนินการกะขององค์ประกอบทางด้านขวาจะเกิดขึ้น

รายการที่เชื่อมโยง:

• ทางเลือกที่ดีที่สุดหากการดำเนินการบ่อยครั้งของเราคือการแทรกและการลบที่จุดเริ่มต้นตรงกลาง
• ทางเลือกที่แย่ที่สุดหากการดำเนินการที่พบบ่อยที่สุดคือการค้นหา

9. องค์ประกอบต่างๆ ถูกจัดเก็บใน HashMap อย่างไร

คอลเลกชันHashMap มี ตาราง Node[]อาร์เรย์ภายในซึ่งเซลล์เหล่านี้เรียกว่าที่เก็บข้อมูล โหนดประกอบด้วย:

• คีย์ - ลิงก์ไปยังคีย์
• ค่า - อ้างอิงถึงค่า
• แฮช - ค่าแฮช
• ถัดไป - เชื่อมโยงไปยังโหนด ถัด ไป

เซลล์หนึ่งของ อาร์เรย์ table[]อาจมีการอ้างอิงไปยัง วัตถุ Nodeพร้อมลิงก์ไปยัง องค์ประกอบ Node ถัดไป และอาจมีลิงก์ไปยังอีกองค์ประกอบหนึ่ง และอื่นๆ... ด้วยเหตุนี้ องค์ประกอบ Node เหล่านี้ จึงสามารถสร้าง รายการที่เชื่อมโยงเดี่ยวโดยมีองค์ประกอบพร้อมลิงก์ไปยังรายการถัดไป ในกรณีนี้ ค่า แฮชขององค์ประกอบของเชนเดียวกันจะเท่ากัน หลังจากการอธิบายสั้นๆ มาดูกันว่าองค์ประกอบต่างๆ ถูกจัดเก็บในHashMap อย่างไร :

1. คีย์ถูกตรวจสอบว่าเป็นโมฆะ หากเป็นnullคีย์จะถูกเก็บไว้ใน เซลล์ table[0]เนื่องจากรหัสแฮชสำหรับ null จะเป็น 0 เสมอ
2. หากคีย์ไม่ใช่null ก็จะเรียกเมธอด hashcode()ของอ็อบเจ็กต์ คีย์ ซึ่งจะส่งคืนโค้ดแฮชของมัน รหัสแฮชนี้ใช้เพื่อกำหนดเซลล์อาร์เรย์ที่จะจัดเก็บวัตถุโหนด
3. ถัดไป โค้ดแฮช นี้จะถูกวางไว้ใน เมธอด hash() ภายใน ซึ่งจะคำนวณแฮชโค้ด แต่จะอยู่ภายในขนาดของ อาร์เรย์ table[]
4. ถัดไป ขึ้นอยู่กับค่าแฮช โหนดจะถูกวางในเซลล์เฉพาะใน อาร์เรย์ table[ ]
5. หาก เซลล์ table[] ที่ใช้ในการบันทึกองค์ประกอบ Nodeปัจจุบันไม่ว่างเปล่า แต่มีองค์ประกอบบางส่วนอยู่แล้ว องค์ประกอบ Node จะถูกวนซ้ำใน ค่าถัดไปจนกว่าจะถึงองค์ประกอบสุดท้าย นั่นคืออันที่ฟิลด์ ถัดไปเป็นnull

   ในระหว่างการค้นหานี้ คีย์ของ ออบเจ็กต์ Node ที่ได้รับการป้องกันจะถูกเปรียบเทียบ กับคีย์ของคีย์ที่กำลังค้นหา:

   • หากพบการจับคู่ การค้นหาจะสิ้นสุด และโหนด ใหม่ จะเขียนทับโหนดที่พบการจับคู่ (เฉพาะ ฟิลด์ ค่า เท่านั้นที่จะถูกเขียนทับ );
   • หากไม่พบคีย์ที่ตรงกันโหนด ใหม่ จะกลายเป็นโหนดสุดท้ายในรายการนี้ และโหนดก่อนหน้าจะมีลิงก์ถัดไป

คำถามมักเกิดขึ้นระหว่างการสัมภาษณ์: ความขัดแย้งคืออะไร ? สถานการณ์ที่เซลล์ของอาร์เรย์table[]ไม่ได้เก็บองค์ประกอบเดียว แต่เชื่อมต่อกันตั้งแต่สององค์ประกอบขึ้นไป เรียกว่าการชนกัน ในกรณีปกติที่มีองค์ประกอบเดียวเท่านั้นที่ถูกเก็บไว้ใน เซลล์ ตาราง [] เดียวการเข้าถึงองค์ประกอบของHashMapจะมี ความซับซ้อนของเวลา O(1) คง ที่ แต่เมื่อเซลล์ที่มีองค์ประกอบที่ต้องการมีสายโซ่ขององค์ประกอบ ( การชนกัน ) ดังนั้นO(n)เนื่องจากในกรณีนี้ เวลาจะเป็นสัดส่วนโดยตรงกับจำนวนองค์ประกอบที่ถูกจัดเรียง

10. อธิบายตัววนซ้ำ

ใน แผนภาพการแมปลำดับชั้นของคอล เลกชัน ด้านบน อินเทอร์เฟซของ คอลเลกชันคือจุดเริ่มต้นของลำดับชั้นทั้งหมด แต่ในทางปฏิบัติกลับไม่เป็นเช่นนั้น คอลเลกชันสืบทอดมาจากอินเทอร์เฟซด้วยเมธอดiterator()ซึ่งส่งคืนอ็อบเจ็กต์ที่ใช้ อินเทอร์เฟ ซ Iterator<E> อินเทอร์เฟซ Iterator มีลักษณะดังนี้:

public interface Iterator <E>{

    E next();
    boolean hasNext();
    void remove();
}

next() - โดยการเรียกใช้เมธอดนี้ คุณจะได้รับองค์ประกอบถัดไป hasNext() - ช่วยให้คุณค้นหาว่ามีองค์ประกอบถัดไปหรือไม่ และถึงจุดสิ้นสุดของคอลเลกชันแล้วหรือไม่ และเมื่อยังมีองค์ประกอบอยู่hasNext()จะส่งคืนค่าtrue โดยทั่วไปแล้วhasNext()จะถูกเรียกก่อน เมธอด next()เนื่องจากnext()จะส่งNoSuchElementException เมื่อถึงจุดสิ้นสุดของคอลเลก ชัน ลบ() - ลบองค์ประกอบที่ถูกดึงโดยการเรียกครั้งล่าสุดไปยัง next( ) วัตถุประสงค์ของ Iterator คือการวนซ้ำองค์ประกอบต่างๆ ตัวอย่างเช่น:

Set<Integer> values = new TreeSet<>();
  values.add(5);
values.add(3);
values.add(6);
values.add(8);
values.add(2);
values.add(4);
values.add(1);
values.add(7);

Iterator<Integer> iter = values.iterator();
while(iter.hasNext()){
  System.out.println(iter.next());
}

จริงๆ แล้วfor-each loopถูกนำมาใช้ภายใต้ประทุนโดยใช้ตัววนซ้ำ คุณสามารถอ่านเพิ่มเติมเกี่ยวกับเรื่องนี้ได้ ที่นี่ Listจัดเตรียมตัววนซ้ำในเวอร์ชันของตัวเอง แต่ตัววนซ้ำที่เจ๋งกว่าและซับซ้อนกว่า- ListIterator อินเทอร์เฟซนี้ขยายIteratorและมีวิธีการเพิ่มเติม:

• hasPreviousจะส่งคืนค่าจริงหากมีองค์ประกอบก่อนหน้าในคอลเลกชัน มิฉะนั้นจะเป็นเท็จ
• Previousส่งคืนองค์ประกอบปัจจุบันและย้ายไปยังองค์ประกอบก่อนหน้า หากไม่มีเลย NoSuchElementException จะถูกส่งออกไป
• addจะแทรกวัตถุที่ส่งผ่านก่อนที่องค์ประกอบที่จะถูกส่งกลับโดยการเรียกครั้งต่อไปที่next() ;
• ชุดกำหนดองค์ประกอบปัจจุบันการอ้างอิงไปยังวัตถุที่ส่งผ่าน;
• nextIndexส่งกลับดัชนีขององค์ประกอบถัดไป หากไม่มีสิ่งนั้น ขนาดของรายการจะถูกส่งคืน
• PreviousIndexส่งกลับดัชนีขององค์ประกอบก่อนหน้า หากไม่มี ก็จะส่งกลับตัวเลข -1

นั่นคือทั้งหมดสำหรับฉันในวันนี้ ฉันหวังว่าหลังจากอ่านบทความนี้แล้ว คุณจะยิ่งเข้าใกล้ความฝันอันหวงแหนของคุณมากขึ้น - ในการเป็นนักพัฒนา