ดอกไม้เพลิง! การเป็นโปรแกรมเมอร์ไม่ใช่เรื่องง่าย คุณต้องเรียนรู้อย่างต่อเนื่อง เรียนรู้สิ่งใหม่ ๆ อยู่เสมอ แต่เช่นเดียวกับธุรกิจอื่นๆ สิ่งที่ยากที่สุดคือการเริ่มต้น ก้าวแรกไปสู่เป้าหมายของคุณ และเนื่องจากคุณกำลังนั่งอยู่บนเว็บไซต์นี้และอ่านบทความนี้ แสดงว่าคุณได้ทำขั้นตอนแรกเสร็จสิ้นแล้ว ซึ่งหมายความว่าตอนนี้คุณต้องก้าวไปสู่เป้าหมายอย่างมีจุดมุ่งหมาย โดยไม่ทำให้ช้าลงหรือดับไประหว่างทาง ถ้าฉันเข้าใจถูกต้อง เป้าหมายของคุณคือการเป็น Java Developer หรือเพิ่มพูนความรู้หากคุณเป็นคนหนึ่ง หากเป็นเช่นนั้น แสดงว่าคุณมาถูกที่แล้ว เพราะเราจะยังคงวิเคราะห์รายการคำถามสัมภาษณ์นักพัฒนา Java มากกว่า 250 ข้อต่อไป
มาต่อกัน!
ในทางกลับกัน จะแบ่งออกเป็นคอลเลกชันย่อยต่อไปนี้:
ในคอลเลกชันนี้ไม่มีการแบ่งออกเป็นคอลเลกชันย่อย (เนื่องจาก ลำดับชั้นของ แผนที่ เอง ก็เหมือนกับคอลเลกชันย่อย แต่จะแยกจากกัน) การใช้ งานแผนที่มาตรฐานคือHashtable (ถือว่าเลิกใช้แล้ว), LinkedHashMapและTreeMap จริงๆ แล้ว เมื่อถามเกี่ยวกับCollectionก็มักจะหมายถึงทั้งสองลำดับชั้น
ในArrayListเมื่อรายการเพิ่มขึ้น อาร์เรย์ภายในก็เพิ่มขึ้น แต่ที่นี่ทุกอย่างเกิดขึ้นได้ง่ายขึ้น - เมื่อเพิ่มองค์ประกอบ ลิงก์สองสามรายการก็เปลี่ยนไป มาดูเมธอดLinkedlList ที่ใช้บ่อยที่สุดกัน : 1. add(<Elelement>) - การเพิ่มที่ส่วนท้ายของรายการ เช่น หลังจากองค์ประกอบสุดท้าย (5) ลิงก์ไปยังองค์ประกอบใหม่จะถูกเพิ่มเป็นถัดไป องค์ประกอบใหม่จะมีลิงก์ไปยังองค์ประกอบสุดท้าย (5) เป็นองค์ประกอบก่อนหน้า ความซับซ้อนของลอการิทึมของการดำเนินการดังกล่าวจะเป็น O(1) เนื่องจากจำเป็นต้องมีลิงก์ไปยังองค์ประกอบสุดท้ายเท่านั้น และอย่างที่คุณจำได้ ส่วนท้ายมีลิงก์โดยตรงจากLinkedListและความซับซ้อนของลอการิทึมในการเข้าถึงนั้นมีน้อยมาก 2. add(<Index>,<Elelement>) - การเพิ่มองค์ประกอบตามดัชนี เมื่อเพิ่มองค์ประกอบ เช่น ตรงกลางรายการ องค์ประกอบจากส่วนหัวและส่วนท้าย (ทั้งสองด้าน) จะถูกวนซ้ำก่อนจนกว่าจะพบตำแหน่งที่ต้องการ หากเราต้องการแทรกองค์ประกอบระหว่างองค์ประกอบที่สามและสี่ (ในรูปด้านบน) เมื่อค้นหาตำแหน่งที่ถูกต้อง ลิงค์ ถัดไปขององค์ประกอบที่สามจะชี้ไปที่องค์ประกอบใหม่แล้ว สำหรับอันใหม่ ลิงค์ ก่อนหน้าจะชี้ไปที่อันที่สาม ดังนั้นลิงก์ขององค์ประกอบที่สี่ - ก่อนหน้า - จะชี้ไปที่องค์ประกอบใหม่แล้วและ ลิงก์ ถัดไป ขององค์ประกอบใหม่ จะชี้ไปที่องค์ประกอบที่สี่:
ความซับซ้อนของลอการิทึมของวิธีนี้จะขึ้นอยู่กับดัชนีที่กำหนดให้กับองค์ประกอบใหม่:
ผลลัพธ์คือกระบวนการผกผันกับการเพิ่มโดยดัชนี ( add(<Index>,<Elelement>) ) สำหรับผู้ที่ต้องการเรียนรู้เพิ่มเติมเกี่ยวกับโครงสร้างภายในของ LinkedListฉันขอแนะนำให้อ่านบทความนี้
จริงๆ แล้ว "ลิงก์ไปยังองค์ประกอบถัดไป" หมายความว่าเรากำลังจัดการกับรายการลิงก์เดี่ยว โดยที่แต่ละองค์ประกอบมีลิงก์ไปยัง อันถัดไป นั่นคือHashMapจัดเก็บข้อมูลไว้ในอาร์เรย์ของรายการที่เชื่อมโยงเดี่ยวๆ แต่ฉันจะสังเกตทันที: เมื่อเซลล์หนึ่งของ อาร์เรย์ ตารางมีลิงก์ไปยังรายการที่เชื่อมโยงเดี่ยวที่คล้ายกันซึ่งประกอบด้วยองค์ประกอบมากกว่าหนึ่งองค์ประกอบ สิ่งนี้ไม่ดี ปรากฏการณ์นี้เรียกว่าการชนกัน แต่สิ่งแรกก่อน มาดูกันว่าคู่ใหม่จะถูกบันทึกโดยใช้ วิธี putอย่างไร ขั้นแรก ให้ใช้ hachCode()ของคีย์ ดังนั้น เพื่อให้แฮชแมป ทำงานได้อย่างถูกต้อง คุณจะต้องเรียนคลาสที่เมธอดนี้ถูกแทนที่เป็นคีย์ รหัสแฮชนี้จะถูกใช้ในวิธีการภายใน - hash () - เพื่อกำหนดหมายเลขภายในขนาดของ อาร์เรย์ ตาราง ถัดไปโดยใช้หมายเลขที่ ได้ รับ เข้าถึงเซลล์เฉพาะของอาร์เรย์ตาราง ที่นี่เรามีสองกรณี:
HashMapเป็นหัวข้อใหญ่ และผู้คนชอบถามคำถามเกี่ยวกับเรื่องนี้ในการสัมภาษณ์ เลยแนะนำให้ทำความเข้าใจให้ละเอียด (จะได้เด้งหลุดฟัน) โดยส่วนตัวแล้วฉันไม่เคยมีการสัมภาษณ์โดยไม่มีคำถามHashMap คุณสามารถดูข้อมูลเจาะลึก เกี่ยวกับ HashMapได้ในบทความนี้ วันนี้พอแค่นี้ก่อนนะครับ...จะติดตามต่อไป...
คอลเลกชัน
84. บอกเราเกี่ยวกับตัววนซ้ำและการใช้งาน
คอลเลกชันเป็นหนึ่งในหัวข้อที่ชื่นชอบในการสัมภาษณ์นักพัฒนา Java และเมื่อพูดถึงลำดับชั้นของคอลเลกชัน ผู้สมัครมักจะบอกว่ามันเริ่มต้นด้วย อินเทอร์เฟซ ของคอลเลกชัน แต่สิ่งนี้ไม่เป็นความจริง เพราะเหนืออินเทอร์เฟ ซนี้มีอีกอันหนึ่ง - Iterable อินเทอร์เฟซนี้แสดงถึง เมธอด iterator()ซึ่งช่วยให้คุณเรียกใช้ อ็อบเจ็กต์ Iteratorสำหรับคอลเล็กชันปัจจุบันได้ และวัตถุ Iteratorนี้คืออะไรกันแน่? Iteratorคืออ็อบเจ็กต์ที่ให้ความสามารถในการเคลื่อนที่ผ่านคอลเลกชันและวนซ้ำองค์ประกอบโดยที่ผู้ใช้ไม่จำเป็นต้องทราบถึงการใช้งานคอลเลกชันใดคอลเลกชันหนึ่งโดยเฉพาะ นั่นคือนี่คือตัวชี้ไปยังองค์ประกอบของคอลเลกชันซึ่งดูเหมือนว่าจะดูที่สถานที่บางแห่งในนั้น ตัววนซ้ำมีวิธีการดังต่อไปนี้:- hasNext() - คืนค่าเป็นจริงหากมีองค์ประกอบอยู่หลังตัวชี้ (วิธีนี้ช่วยให้คุณทราบว่าถึงจุดสิ้นสุดของคอลเลกชันแล้วหรือไม่)
- ถัดไป() - ส่งคืนองค์ประกอบถัดไปหลังจากตัวชี้ หากไม่มีเลยNoSuchElementException จะถูกส่งออก ไป นั่นคือ ก่อนที่จะใช้วิธีนี้ ควรตรวจสอบให้แน่ใจว่ามีองค์ประกอบนั้นอยู่ก่อน โดยใช้hasNext() ;
- ลบ() - ลบองค์ประกอบสุดท้ายที่ได้รับจากคอลเลกชันโดยใช้เมธอดnext() หากไม่เคยมีการเรียกnext() ก่อนที่จะมีการเรียก Remove() ข้อยกเว้นจะถูกส่งออกไป - IllegalStateException ;
- forEachRemaining(<Consumer>) - ดำเนินการที่ส่งผ่านกับแต่ละองค์ประกอบของคอลเลกชัน (วิธีการปรากฏใน Java 8)
List<String> list = new ArrayList<>();
list.add("Hello ");
list.add("World, ");
list.add("It's ");
list.add("Amigo!");
Iterator iterator = list.iterator();
while(iterator.hasNext()) {
iterator.next();
iterator.remove();
}
System.out.println(list.size());
คอนโซลจะแสดง:
0
ซึ่งหมายความว่าการลบองค์ประกอบสำเร็จ เมื่อเรามีตัววนซ้ำแล้ว เราก็สามารถใช้วิธีพิมพ์องค์ประกอบทั้งหมดลงบนหน้าจอได้:
iterator.forEachRemaining(x -> System.out.print(x));
แต่หลังจากนี้ ตัววนซ้ำจะไม่เหมาะสำหรับการใช้งานต่อไป เนื่องจากตัววนซ้ำจะข้ามรายการทั้งหมด และตัววนซ้ำทั่วไปไม่มีวิธีในการย้อนรอย ที่นี่เราจะค่อยๆ เข้าใกล้LinkedList กล่าวคือlistIterator() วิธีการ ซึ่งส่งคืนตัววนซ้ำประเภทที่ทันสมัย - ListIterator นอกจากวิธีการวนซ้ำปกติ (มาตรฐาน) แล้ว วิธีนี้ยังมีวิธีเพิ่มเติม:
- add(<Element>) - แทรกองค์ประกอบใหม่ลงในรายการ
- hasPrevious() - คืนค่าจริงหากมีองค์ประกอบอยู่หน้าตัวชี้ (ไม่ว่าจะมีองค์ประกอบก่อนหน้าหรือไม่)
- nextIndex() - ส่งคืนดัชนีในรายการองค์ประกอบถัดไปหลังตัวชี้
- ก่อนหน้า() - ส่งคืนองค์ประกอบก่อนหน้า (ขึ้นอยู่กับตัวชี้);
- PreviousIndex() - ส่งคืนดัชนีขององค์ประกอบก่อนหน้า
- set(<Element>) - แทนที่องค์ประกอบสุดท้ายที่ส่งคืนโดย เมธอด next()หรือPrevious( )

85. ลำดับชั้นของคอลเลกชันใน Java Collection Framework คืออะไร?
Java มีลำดับชั้นการรวบรวมอยู่สองลำดับ ลำดับชั้นแรกคือ ลำดับชั้นของ คอลเลกชันซึ่งมีโครงสร้างดังต่อไปนี้:
- Setเป็นอินเทอร์เฟซที่อธิบายโครงสร้างข้อมูลดังกล่าวเป็นชุดที่มีองค์ประกอบเฉพาะที่ไม่เรียงลำดับ (ไม่ซ้ำกัน) อินเทอร์เฟ ซมีการใช้งานมาตรฐาน - TreeSet , HashSetและLinkedHashSet
- รายการคืออินเทอร์เฟซที่อธิบายโครงสร้างข้อมูลที่จัดเก็บลำดับของออบเจ็กต์ อินสแตนซ์ที่มีอยู่ในรายการสามารถแทรกและลบได้โดยดัชนีในคอลเลกชันนี้ (คล้ายกับอาร์เรย์ แต่มีการปรับขนาดแบบไดนามิก) อินเทอร์เฟ ซมีการใช้งานมาตรฐาน - ArrayList , Vector ( ถือว่าล้าสมัยและไม่ได้ใช้จริง ) และLinkedList
- คิว เป็นอินเทอร์เฟซที่อธิบายโครงสร้าง ข้อมูลที่จัดเก็บองค์ประกอบในรูปแบบของคิวที่เป็นไปตาม กฎ FIFO - เข้าก่อนออกก่อน อินเทอร์เฟ ซมีการใช้งานมาตรฐานดังต่อไปนี้: LinkedList (ใช่ นอกจากนี้ยังใช้Queueด้วย) และPriotityQueue


86. โครงสร้างภายในของ ArrayList คืออะไร?
ArrayListคล้ายกับอาร์เรย์ แต่มีความสามารถในการขยายแบบไดนามิก มันหมายความว่าอะไร? ความจริงก็คือArrayListทำงานบนพื้นฐานของอาร์เรย์ปกติ กล่าวคือ เก็บองค์ประกอบไว้ในอาร์เรย์ภายใน (ขนาดเริ่มต้นคือ 10 เซลล์) เมื่ออาร์เรย์ภายในเต็ม จะมีการสร้างอาร์เรย์ใหม่ ซึ่งขนาดจะถูกกำหนดโดยสูตร:<размерТекущегоМассива> * 3 / 2 + 1
นั่นคือถ้าขนาดของอาร์เรย์ของเราคือ 10 ขนาดของอาร์เรย์ใหม่จะเป็น: 10 * 3/2 + 1 = 16 ถัดไป ค่าทั้งหมดจากอาร์เรย์แรก (เก่า) จะถูกคัดลอกไปโดยใช้ System.arraycopy () วิธีการดั้งเดิม และอาร์เรย์แรกจะถูกลบ จริงๆ แล้วนี่คือวิธีการใช้ความสามารถในการขยายแบบไดนามิกของArrayList มาดู วิธีการ ArrayList ที่ใช้กันมากที่สุด : 1. add(<Elelement>) - เพิ่มองค์ประกอบที่ส่วนท้ายของอาร์เรย์ (ไปยังเซลล์ว่างสุดท้าย) และขั้นแรกให้ตรวจสอบว่ามีช่องว่างในอาร์เรย์นี้หรือไม่ หากไม่มีอยู่ จะมีการสร้างอาร์เรย์ใหม่เพื่อคัดลอกองค์ประกอบลงไป ความซับซ้อนของลอการิทึมของการดำเนินการนี้คือ O(1) มีวิธีที่คล้ายกัน - add (<Index>,<Elelement>) โดยจะเพิ่มองค์ประกอบไม่ต่อท้ายรายการ (อาร์เรย์) แต่เพิ่มไปยังเซลล์เฉพาะที่มีดัชนีที่มาในรูปแบบอาร์กิวเมนต์ ในกรณีนี้ ความซับซ้อนของลอการิทึมจะแตกต่างกันไปขึ้นอยู่กับตำแหน่งที่บวก:
- หากนี่คือจุดเริ่มต้นของรายการโดยประมาณ ความซับซ้อนของลอการิทึมจะใกล้เคียงกับ O(N) เนื่องจากองค์ประกอบทั้งหมดที่อยู่ทางด้านขวาของรายการใหม่จะต้องย้ายหนึ่งเซลล์ไปทางขวา
- ถ้าองค์ประกอบถูกแทรกไว้ตรงกลาง - O(N/2) เพราะ เราจำเป็นต้องย้ายองค์ประกอบรายการเพียงครึ่งเดียวไปทางขวาหนึ่งเซลล์

87. โครงสร้างภายในของ LinkedList คืออะไร?
หากArrayListมีองค์ประกอบในอาร์เรย์ภายในLinkedListจะอยู่ในรูปแบบของรายการที่เชื่อมโยงแบบทวีคูณ ซึ่งหมายความว่าแต่ละองค์ประกอบมีลิงค์ไปยังองค์ประกอบก่อนหน้า ( ก่อนหน้า ) และองค์ประกอบถัดไป ( ถัดไป ) องค์ประกอบแรกไม่มีลิงก์ไปยังองค์ประกอบก่อนหน้า (เป็นองค์ประกอบแรก) แต่ถือเป็นส่วนหัวของรายการ และ LinkedList มีลิงก์ไปยังองค์ประกอบโดยตรง ที่จริงแล้วองค์ประกอบสุดท้ายไม่มีองค์ประกอบถัดไป แต่เป็นส่วนท้ายของรายการ ดังนั้นจึงมีลิงก์โดยตรงไปยังองค์ประกอบนั้นในLinkedListนั่นเอง ดังนั้นความซับซ้อนของลอการิทึมในการเข้าถึงส่วนหัวหรือส่วนท้ายของรายการคือ O(1)

- ถ้ามันอยู่ใกล้กับหัวหรือหาง มันจะเข้าใกล้ O(1) เนื่องจากจริงๆ แล้วมันไม่จำเป็นที่จะต้องวนซ้ำองค์ประกอบต่างๆ
- ถ้าอยู่ใกล้ตรงกลาง O(N/2) - องค์ประกอบจากส่วนหัวและส่วนท้ายจะถูกจัดเรียงพร้อมกันจนกว่าจะพบองค์ประกอบที่ต้องการ

88. โครงสร้างภายในของ HashMap คืออะไร?
บางทีหนึ่งในคำถามยอดนิยมเมื่อสัมภาษณ์นักพัฒนา Java HashMap v ทำงานร่วมกับคู่คีย์-ค่า พวกมันถูกเก็บไว้ในHashMapvอย่างไร ภายในHashMapมีอาร์เรย์ของโหนด:Node<K,V>[] table
ตามค่าเริ่มต้น ขนาดของอาร์เรย์คือ 16 และจะเพิ่มเป็นสองเท่าในแต่ละครั้งเมื่อมีการเติมองค์ประกอบ (เมื่อถึงLOAD_FACTOR - เปอร์เซ็นต์ของความสมบูรณ์ที่แน่นอน โดยค่าเริ่มต้นคือ0.75 ) แต่ละโหนดจะเก็บแฮชของคีย์ คีย์ ค่า และลิงก์ไปยังองค์ประกอบถัดไป 
- เซลล์ว่างเปล่า - ค่า โหนด ใหม่จะถูกเก็บไว้ใน นั้น
- เซลล์ไม่ว่างเปล่า - มีการเปรียบเทียบค่าของคีย์ หากเท่ากัน ค่า โหนด ใหม่จะเขียนทับค่าเก่า หากไม่เท่ากัน จะมีการเข้าถึงองค์ประกอบ ถัดไปและเปรียบเทียบกับคีย์ของมัน... และต่อ ๆ ไปจนกว่าค่าใหม่จะเขียนทับค่าเก่าบางส่วนหรือถึงจุดสิ้นสุดของ รายการที่เชื่อมโยงเดี่ยวๆ และจะถูกเก็บไว้ที่นั่นเป็นองค์ประกอบสุดท้าย


GO TO FULL VERSION