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

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

คอลเลกชัน

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

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

85. Java Collection Framework มีลำดับชั้นของคอลเลกชันใดบ้าง

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

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

• รายการเป็นอินเทอร์เฟซที่อธิบายโครงสร้างข้อมูลที่จัดเก็บลำดับของออบเจ็กต์ ออบเจ็กต์ในรายการสามารถแทรกและลบออกได้โดยดัชนีในรายการ (เช่นอาร์เรย์ แต่ด้วยการปรับขนาดแบบไดนามิก) อินเทอร์เฟซนี้มีการใช้งานมาตรฐานบางอย่าง: ArrayList , Vector (เลิกใช้แล้วและไม่ได้ใช้จริง ) และLinkedList

• Queueคืออินเทอร์เฟซที่อธิบายโครงสร้างข้อมูลที่จัดเก็บรายการต่างๆ ในคิวเข้าก่อนออกก่อน (FIFO) อินเทอร์เฟซนี้มีการใช้ งานมาตรฐานดังต่อไปนี้: LinkedList (ใช่แล้ว นอกจากนี้ยังใช้Queue ) และPriotityQueue

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

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

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

<size of the current array> * 3 / 2 + 1

ดังนั้นหากขนาดของอาร์เรย์ของเราคือ 10 ขนาดของอาร์เรย์ใหม่จะเป็น: 10 * 3/2 + 1 = 16 จากนั้นค่าทั้งหมดจากอาร์เรย์ดั้งเดิม (เก่า) จะถูกคัดลอกไปไว้โดยใช้ในตัวSystem.arraycopy()วิธีการและอาร์เรย์เดิมจะถูกลบ โดยสรุป นั่นคือวิธีที่ArrayListใช้การปรับขนาดแบบไดนามิก ลองพิจารณา วิธีการ ArrayList ที่ได้รับความนิยมมากที่สุด : 1. add(<Element>) — เพิ่มองค์ประกอบที่ส่วนท้ายของอาร์เรย์ (ในเซลล์ว่างสุดท้าย) หลังจากตรวจสอบครั้งแรกว่ามีเซลล์ว่างในอาร์เรย์หรือไม่ ถ้าไม่เช่นนั้น จะมีการสร้างอาร์เรย์ใหม่และองค์ประกอบต่างๆ จะถูกคัดลอกลงไป ความซับซ้อนของเวลาของการดำเนินการนี้คือ O(1) มีเมธอดadd(<Index>, <Elelement>) ที่คล้ายกัน โดยจะเพิ่มองค์ประกอบไม่ต่อท้ายรายการ (อาร์เรย์) แต่เพิ่มไปยังเซลล์เฉพาะที่ระบุโดยดัชนีที่เข้ามาเป็นอาร์กิวเมนต์ ในกรณีนี้ ความซับซ้อนของเวลาจะแตกต่างกันไปขึ้นอยู่กับตำแหน่งที่คุณเพิ่ม:

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

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

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

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

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

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

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

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

Node<K,V>[] table

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

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

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