การวิเคราะห์คำถามและคำตอบจากการสัมภาษณ์นักพัฒนา Java ตอนที่ 9

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

คอลเลกชัน

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());

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

iterator.forEachRemaining(x -> System.out.print(x));

แต่หลังจากนี้ ตัววนซ้ำจะไม่เหมาะสำหรับการใช้งานต่อไป เนื่องจากตัววนซ้ำจะข้ามรายการทั้งหมด และตัววนซ้ำทั่วไปไม่มีวิธีในการย้อนรอย ที่นี่เราจะค่อยๆ เข้าใกล้LinkedList กล่าวคือlistIterator() วิธีการ ซึ่งส่งคืนตัววนซ้ำประเภทที่ทันสมัย ​​- ListIterator นอกจากวิธีการวนซ้ำปกติ (มาตรฐาน) แล้ว วิธีนี้ยังมีวิธีเพิ่มเติม:

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

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

85. ลำดับชั้นของคอลเลกชันใน Java Collection Framework คืออะไร?

Java มีลำดับชั้นการรวบรวมอยู่สองลำดับ ลำดับชั้นแรกคือ ลำดับชั้นของ คอลเลกชันซึ่งมีโครงสร้างดังต่อไปนี้: ในทางกลับกัน จะแบ่งออกเป็นคอลเลกชันย่อยต่อไปนี้:

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

ลำดับชั้นที่สองของคอลเลกชันคือMapซึ่งมีโครงสร้างดังต่อไปนี้: ในคอลเลกชันนี้ไม่มีการแบ่งออกเป็นคอลเลกชันย่อย (เนื่องจาก ลำดับชั้นของ แผนที่ เอง ก็เหมือนกับคอลเลกชันย่อย แต่จะแยกจากกัน) การใช้ งานแผนที่มาตรฐานคือHashtable (ถือว่าเลิกใช้แล้ว), LinkedHashMapและTreeMap จริงๆ แล้ว เมื่อถามเกี่ยวกับCollectionก็มักจะหมายถึงทั้งสองลำดับชั้น

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) เพราะ เราจำเป็นต้องย้ายองค์ประกอบรายการเพียงครึ่งเดียวไปทางขวาหนึ่งเซลล์

นั่นคือความซับซ้อนของลอการิทึมของวิธีการนี้มีตั้งแต่ O(N) ถึง O(1) ขึ้นอยู่กับตำแหน่งที่องค์ประกอบถูกแทรก 2. set(<Index>,<Elelement>) - เขียนองค์ประกอบไปยังตำแหน่งที่ระบุในรายการ หากมีองค์ประกอบอยู่ที่ตำแหน่งนั้นอยู่แล้ว ให้เขียนทับองค์ประกอบนั้น ความซับซ้อนของลอการิทึมของการดำเนินการนี้คือ O(1) เนื่องจากไม่มีการเปลี่ยนแปลง: มีเพียงการค้นหาด้วยดัชนีในอาร์เรย์ ซึ่งตามที่เราจำได้มีความซับซ้อนเท่ากับ O(1) และการเขียนองค์ประกอบ 3. ลบ(<index>) - ลบองค์ประกอบโดยดัชนีในอาร์เรย์ภายใน เมื่อลบรายการที่ไม่ได้อยู่ท้ายรายการ คุณต้องย้ายรายการทั้งหมดไปทางขวาของเซลล์หนึ่งเซลล์ไปทางซ้ายเพื่อปิดช่องว่างด้านซ้ายหลังจากลบรายการ ดังนั้น ความซับซ้อนของลอการิทึมจะเหมือนกับadd(<Index>,<Elelement>)หากองค์ประกอบอยู่ตรงกลาง - O(N/2) - เนื่องจากคุณต้องเลื่อนองค์ประกอบครึ่งหนึ่งไปทางซ้ายหนึ่งองค์ประกอบ ดังนั้นหากเป็นจุดเริ่มต้น - O(N) ถ้าสุดท้ายเป็น O(1) ก็ไม่จำเป็นต้องย้ายอะไรเลย สำหรับผู้ที่ต้องการเจาะลึกหัวข้อนี้ ฉันจะทิ้งลิงก์ นี้ไปยังบทความพร้อมการวิเคราะห์ คลาส ArrayList

87. โครงสร้างภายในของ LinkedList คืออะไร?

หากArrayListมีองค์ประกอบในอาร์เรย์ภายในLinkedListจะอยู่ในรูปแบบของรายการที่เชื่อมโยงแบบทวีคูณ ซึ่งหมายความว่าแต่ละองค์ประกอบมีลิงค์ไปยังองค์ประกอบก่อนหน้า ( ก่อนหน้า ) และองค์ประกอบถัดไป ( ถัดไป ) องค์ประกอบแรกไม่มีลิงก์ไปยังองค์ประกอบก่อนหน้า (เป็นองค์ประกอบแรก) แต่ถือเป็นส่วนหัวของรายการ และ LinkedList มีลิงก์ไปยังองค์ประกอบโดยตรง ที่จริงแล้วองค์ประกอบสุดท้ายไม่มีองค์ประกอบถัดไป แต่เป็นส่วนท้ายของรายการ ดังนั้นจึงมีลิงก์โดยตรงไปยังองค์ประกอบนั้นในLinkedListนั่นเอง ดังนั้นความซับซ้อนของลอการิทึมในการเข้าถึงส่วนหัวหรือส่วนท้ายของรายการคือ O(1) ในArrayListเมื่อรายการเพิ่มขึ้น อาร์เรย์ภายในก็เพิ่มขึ้น แต่ที่นี่ทุกอย่างเกิดขึ้นได้ง่ายขึ้น - เมื่อเพิ่มองค์ประกอบ ลิงก์สองสามรายการก็เปลี่ยนไป มาดูเมธอดLinkedlList ที่ใช้บ่อยที่สุดกัน : 1. add(<Elelement>) - การเพิ่มที่ส่วนท้ายของรายการ เช่น หลังจากองค์ประกอบสุดท้าย (5) ลิงก์ไปยังองค์ประกอบใหม่จะถูกเพิ่มเป็นถัดไป องค์ประกอบใหม่จะมีลิงก์ไปยังองค์ประกอบสุดท้าย (5) เป็นองค์ประกอบก่อนหน้า ความซับซ้อนของลอการิทึมของการดำเนินการดังกล่าวจะเป็น O(1) เนื่องจากจำเป็นต้องมีลิงก์ไปยังองค์ประกอบสุดท้ายเท่านั้น และอย่างที่คุณจำได้ ส่วนท้ายมีลิงก์โดยตรงจากLinkedListและความซับซ้อนของลอการิทึมในการเข้าถึงนั้นมีน้อยมาก 2. add(<Index>,<Elelement>) - การเพิ่มองค์ประกอบตามดัชนี เมื่อเพิ่มองค์ประกอบ เช่น ตรงกลางรายการ องค์ประกอบจากส่วนหัวและส่วนท้าย (ทั้งสองด้าน) จะถูกวนซ้ำก่อนจนกว่าจะพบตำแหน่งที่ต้องการ หากเราต้องการแทรกองค์ประกอบระหว่างองค์ประกอบที่สามและสี่ (ในรูปด้านบน) เมื่อค้นหาตำแหน่งที่ถูกต้อง ลิงค์ ถัดไปขององค์ประกอบที่สามจะชี้ไปที่องค์ประกอบใหม่แล้ว สำหรับอันใหม่ ลิงค์ ก่อนหน้าจะชี้ไปที่อันที่สาม ดังนั้นลิงก์ขององค์ประกอบที่สี่ - ก่อนหน้า - จะชี้ไปที่องค์ประกอบใหม่แล้วและ ลิงก์ ถัดไป ขององค์ประกอบใหม่ จะชี้ไปที่องค์ประกอบที่สี่: ความซับซ้อนของลอการิทึมของวิธีนี้จะขึ้นอยู่กับดัชนีที่กำหนดให้กับองค์ประกอบใหม่:

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

3. set(<Index>,<Elelement>) - เขียนองค์ประกอบไปยังตำแหน่งที่ระบุในรายการ ความซับซ้อนของลอการิทึมของการดำเนินการนี้จะอยู่ในช่วงตั้งแต่ O(1) ถึง O(N/2) อีกครั้ง ขึ้นอยู่กับว่าองค์ประกอบอยู่ใกล้หัว หาง หรือตรงกลางแค่ไหน 4. ลบ(<index>) - ลบองค์ประกอบออกจากรายการ โดยพื้นฐานแล้วทำให้องค์ประกอบที่อยู่ก่อนที่จะถูกลบออก ( Previous ) อ้างอิงถึงองค์ประกอบที่มาหลังจากองค์ประกอบที่ถูกลบออก ( next ) และในทางกลับกัน: เพื่อให้องค์ประกอบที่มาหลังจากองค์ประกอบที่ถูกลบหมายถึงองค์ประกอบที่มาก่อนที่จะถูกลบ: ผลลัพธ์คือกระบวนการผกผันกับการเพิ่มโดยดัชนี ( add(<Index>,<Elelement>) ) สำหรับผู้ที่ต้องการเรียนรู้เพิ่มเติมเกี่ยวกับโครงสร้างภายในของ LinkedListฉันขอแนะนำให้อ่านบทความนี้

88. โครงสร้างภายในของ HashMap คืออะไร?

บางทีหนึ่งในคำถามยอดนิยมเมื่อสัมภาษณ์นักพัฒนา Java HashMap v ทำงานร่วมกับคู่คีย์-ค่า พวกมันถูกเก็บไว้ในHashMapvอย่างไร ภายในHashMapมีอาร์เรย์ของโหนด:

Node<K,V>[] table

ตามค่าเริ่มต้น ขนาดของอาร์เรย์คือ 16 และจะเพิ่มเป็นสองเท่าในแต่ละครั้งเมื่อมีการเติมองค์ประกอบ (เมื่อถึงLOAD_FACTOR - เปอร์เซ็นต์ของความสมบูรณ์ที่แน่นอน โดยค่าเริ่มต้นคือ0.75 ) แต่ละโหนดจะเก็บแฮชของคีย์ คีย์ ค่า และลิงก์ไปยังองค์ประกอบถัดไป จริงๆ แล้ว "ลิงก์ไปยังองค์ประกอบถัดไป" หมายความว่าเรากำลังจัดการกับรายการลิงก์เดี่ยว โดยที่แต่ละองค์ประกอบมีลิงก์ไปยัง อันถัดไป นั่นคือHashMapจัดเก็บข้อมูลไว้ในอาร์เรย์ของรายการที่เชื่อมโยงเดี่ยวๆ แต่ฉันจะสังเกตทันที: เมื่อเซลล์หนึ่งของ อาร์เรย์ ตารางมีลิงก์ไปยังรายการที่เชื่อมโยงเดี่ยวที่คล้ายกันซึ่งประกอบด้วยองค์ประกอบมากกว่าหนึ่งองค์ประกอบ สิ่งนี้ไม่ดี ปรากฏการณ์นี้เรียกว่าการชนกัน แต่สิ่งแรกก่อน มาดูกันว่าคู่ใหม่จะถูกบันทึกโดยใช้ วิธี putอย่างไร ขั้นแรก ให้ใช้ hachCode()ของคีย์ ดังนั้น เพื่อให้แฮชแมป ทำงานได้อย่างถูกต้อง คุณจะต้องเรียนคลาสที่เมธอดนี้ถูกแทนที่เป็นคีย์ รหัสแฮชนี้จะถูกใช้ในวิธีการภายใน - hash () - เพื่อกำหนดหมายเลขภายในขนาดของ อาร์เรย์ ตาราง ถัดไปโดยใช้หมายเลขที่ ได้ รับ เข้าถึงเซลล์เฉพาะของอาร์เรย์ตาราง ที่นี่เรามีสองกรณี:

1. เซลล์ว่างเปล่า - ค่า โหนด ใหม่จะถูกเก็บไว้ใน นั้น
2. เซลล์ไม่ว่างเปล่า - มีการเปรียบเทียบค่าของคีย์ หากเท่ากัน ค่า โหนด ใหม่จะเขียนทับค่าเก่า หากไม่เท่ากัน จะมีการเข้าถึงองค์ประกอบ ถัดไปและเปรียบเทียบกับคีย์ของมัน... และต่อ ๆ ไปจนกว่าค่าใหม่จะเขียนทับค่าเก่าบางส่วนหรือถึงจุดสิ้นสุดของ รายการที่เชื่อมโยงเดี่ยวๆ และจะถูกเก็บไว้ที่นั่นเป็นองค์ประกอบสุดท้าย

เมื่อค้นหาองค์ประกอบด้วยคีย์ ( get(<key>) method ) hashCodeของคีย์จะถูกคำนวณ จากนั้นค่าของมันภายในอาร์เรย์โดยใช้hash()และใช้ตัวเลขผลลัพธ์ เซลล์ของ อาร์เรย์ ตารางจะถูกพบ ซึ่งการค้นหาได้ดำเนินการไปแล้วโดยการแจกแจงโหนดและเปรียบเทียบคีย์ของโหนดที่ต้องการกับคีย์ของโหนดปัจจุบัน การดำเนินการในMapในสถานการณ์ในอุดมคติมีความซับซ้อนของอัลกอริธึม O(1) เนื่องจากพวกเขากำลังเข้าถึงอาร์เรย์ และดังที่คุณจำได้ โดยไม่คำนึงถึงจำนวนองค์ประกอบ การดำเนินการบนอาร์เรย์จะมีความซับซ้อนเท่ากับ O(1) แต่นี่เป็นอุดมคติ เมื่อเซลล์อาเรย์ที่ใช้ไม่ว่างเปล่า (2) และมีโหนดอยู่บ้างแล้ว ความซับซ้อนของอัลกอริทึมจะกลายเป็นเชิงเส้น O(N) เพราะตอนนี้จำเป็นต้องวนซ้ำองค์ประกอบก่อนที่จะค้นหาตำแหน่งที่ถูกต้อง ฉันอดไม่ได้ที่จะพูดถึงสิ่งนี้: เริ่มต้นด้วย Java 8 หากโหนดรายการที่เชื่อมโยงเดี่ยวมีองค์ประกอบมากกว่า 8 องค์ประกอบ (การชนกัน) โหนดนั้นจะกลายเป็นแผนผังไบนารี ในกรณีนี้ ความซับซ้อนของอัลกอริทึมจะไม่เป็น O(N) อีกต่อไป แต่เป็น O(log(N)) - นั่นเป็นอีกเรื่องหนึ่งใช่ไหม HashMapเป็นหัวข้อใหญ่ และผู้คนชอบถามคำถามเกี่ยวกับเรื่องนี้ในการสัมภาษณ์ เลยแนะนำให้ทำความเข้าใจให้ละเอียด (จะได้เด้งหลุดฟัน) โดยส่วนตัวแล้วฉันไม่เคยมีการสัมภาษณ์โดยไม่มีคำถามHashMap คุณสามารถดูข้อมูลเจาะลึก เกี่ยวกับ HashMapได้ในบทความนี้ วันนี้พอแค่นี้ก่อนนะครับ...จะติดตามต่อไป...