จะมีวัตถุมากมายในการพัฒนาโครงการจริง Java จัดเตรียมกรอบการรวบรวมเพื่อแก้ปัญหาดังกล่าว คลาสอยู่ในแพ็คเกจ java.util และรายการ 1 อธิบายถึงความสัมพันธ์ระหว่างคลาสคอลเลกชัน
รายการ 1. ความสัมพันธ์ระหว่างคลาสคอลเลกชัน
ของสะสม
├ลิสต์
│├ลิงก์ลิสต์
│laarraylist
│orvector
│ kstack
└
แผนที่
Bhashtable
phashmap
Sweakhashmap
อินเทอร์เฟซคอลเลกชัน
อินเทอร์เฟซคอลเลกชัน
คอลเลกชันเป็นอินเทอร์เฟซคอลเลกชันพื้นฐานที่สุด คอลเลกชันบางส่วนอนุญาตองค์ประกอบเดียวกันและสนับสนุนองค์ประกอบการเรียงลำดับในขณะที่อื่น ๆ ไม่ทำงาน JDK ไม่ได้ให้คลาสที่สืบทอดโดยตรงจากคอลเลกชัน คลาสทั้งหมดที่ใช้งานอินเตอร์เฟสการรวบรวมจะต้องมีตัวสร้างมาตรฐานสองตัว ตัวสร้างหลังอนุญาตให้ผู้ใช้คัดลอกคอลเลกชัน
จะทำซ้ำผ่านแต่ละองค์ประกอบในคอลเลกชันได้อย่างไร?
โดยไม่คำนึงถึงประเภทของคอลเลกชันที่แท้จริงมันรองรับวิธีการวนซ้ำ () การใช้งานทั่วไปมีดังนี้:
iterator it = collect.iterator ();
อินเทอร์เฟซทั้งสองของอินเทอร์เฟซคอลเลกชันคือรายการและตั้งค่า
วิธีหลักที่จัดทำโดยอินเทอร์เฟซคอลเลกชัน:
1. บูลีนเพิ่ม (วัตถุ o) เพิ่มวัตถุในการรวบรวม;
2. บูลีนลบ (วัตถุ o) ลบวัตถุที่ระบุ;
3. ขนาด int () ส่งคืนจำนวนองค์ประกอบในคอลเลกชันปัจจุบัน
4. บูลีนมี (วัตถุ o) ค้นหาว่ามีวัตถุที่ระบุในชุดหรือไม่
5. บูลีน isempty () พิจารณาว่าชุดนั้นว่างเปล่าหรือไม่
6. Iterator Iterator () ส่งคืนตัววนซ้ำ
7. บูลีนประกอบด้วย (คอลเลกชัน C) ค้นหาว่ามีองค์ประกอบในชุด C ในชุดหรือไม่
8. บูลีน Addall (คอลเลกชัน C) เพิ่มองค์ประกอบทั้งหมดในคอลเลกชัน C ในคอลเลกชัน
9. เป็นโมฆะ Clear () ลบองค์ประกอบทั้งหมดในชุด;
10. โมฆะ RemoveAll (คอลเลกชัน C) ลบองค์ประกอบในชุด C -Collection จากคอลเลกชัน
11. Void Retainall (Collection C) ลบองค์ประกอบที่ไม่รวมอยู่ในคอลเลกชัน C จากคอลเลกชัน
รายการอินเทอร์เฟซ
รายการเป็นคอลเลกชันที่เป็นระเบียบที่สามารถควบคุมตำแหน่งของการแทรกองค์ประกอบแต่ละอย่างได้อย่างแม่นยำด้วยอินเทอร์เฟซนี้ ผู้ใช้สามารถใช้ดัชนี (ตำแหน่งขององค์ประกอบในรายการคล้ายกับการเสนอราคาอาร์เรย์) เพื่อเข้าถึงองค์ประกอบในรายการซึ่งคล้ายกับอาร์เรย์ Java ไม่เหมือนกับชุดที่จะกล่าวถึงด้านล่างรายการอนุญาตองค์ประกอบเดียวกัน
นอกเหนือจากเมธอด iterator () ที่จำเป็นสำหรับอินเทอร์เฟซคอลเลกชันแล้วรายการยังมีเมธอด listiterator () เพื่อส่งคืนอินเตอร์เฟส listotrator เมื่อเปรียบเทียบกับอินเทอร์เฟซ iterator มาตรฐาน listotrotor มีวิธีการบางอย่างเช่น Add () ซึ่งอนุญาตให้ฟังก์ชั่นเช่นการเพิ่มการลบการตั้งค่าองค์ประกอบการเดินทางไปข้างหน้าหรือย้อนหลัง คลาสที่ใช้กันทั่วไปเพื่อใช้งานอินเตอร์เฟสรายการ ได้แก่ LinkedList, ArrayList, Vector และ Stack
วิธีหลักที่จัดทำโดยรายการอินเทอร์เฟซ:
1. โมฆะเพิ่ม (ดัชนี int, องค์ประกอบวัตถุ) เพิ่มวัตถุที่ตำแหน่งที่ระบุ;
2. บูลีน Addall (Int Interns, Collection C) เพิ่มองค์ประกอบของชุด C ไปยังตำแหน่งที่ระบุ
3. Object Get (INT ดัชนี) ส่งคืนองค์ประกอบที่ระบุในตำแหน่งที่กำหนดในรายการ;
4. ดัชนีของ (วัตถุ o) ส่งคืนตำแหน่งขององค์ประกอบแรก o;
5. Object RemoveInt (INT ดัชนี) ลบองค์ประกอบของตำแหน่งที่ระบุ;
6. ชุดวัตถุ (int indexex, องค์ประกอบวัตถุ) แทนที่องค์ประกอบบนดัชนีตำแหน่งขององค์ประกอบองค์ประกอบเพื่อส่งคืนองค์ประกอบที่เปลี่ยนได้
อินเทอร์เฟซแผนที่
แผนที่ไม่ได้สืบทอดอินเทอร์เฟซ Colleg MAP ให้การแมปจากคีย์ไปยังค่า อินเทอร์เฟซแผนที่มีมุมมอง 3 ชุด
วิธีหลักที่จัดทำโดยแผนที่:
1. บูลีนเท่ากับ (วัตถุ o) วัตถุเปรียบเทียบ;
2. บูลีนลบ (วัตถุ o) ลบวัตถุ;
3. ใส่ (คีย์วัตถุค่าวัตถุ) เพิ่มคีย์และค่า
อินเทอร์เฟซแบบสุ่ม
อินเทอร์เฟซแบบสุ่ม Accter เป็นอินเทอร์เฟซโลโก้ซึ่งไม่ได้ให้วิธีการใด ๆ วัตถุประสงค์หลักของอินเทอร์เฟซนี้คือการระบุการใช้งานรายการที่สามารถรองรับการเข้าถึงที่รวดเร็วและสุ่ม การใช้งานรายการอาร์เรย์ใด ๆ ใช้อินเทอร์เฟซ Raodomaccess ในขณะที่การใช้งานตามรายการที่เชื่อมโยงไม่ได้ เนื่องจากมีเพียงอาร์เรย์เท่านั้นที่สามารถทำการเข้าถึงแบบสุ่มได้อย่างรวดเร็วการเข้าถึงแบบสุ่มไปยังรายการที่เชื่อมโยงจะต้องถูกสำรวจโดยรายการที่เชื่อมโยง ดังนั้นข้อดีของอินเทอร์เฟซนี้คือในแอปพลิเคชันคุณสามารถรู้ได้ว่าวัตถุรายการที่กำลังดำเนินการสามารถดำเนินการเข้าถึงได้อย่างรวดเร็วและสุ่มเพื่อดำเนินการที่แตกต่างกันสำหรับรายการที่แตกต่างกันเพื่อปรับปรุงประสิทธิภาพของโปรแกรม
การแนะนำ
คลาส LinkedList
LinkedList ใช้อินเทอร์เฟซรายการและอนุญาตให้องค์ประกอบ NULL นอกจากนี้ LinkedList ยังให้การลบลบ, แทรกและวิธีอื่น ๆ เพื่อใช้งานข้อมูลที่ LinkedList แรกหรือหาง LinkedList การดำเนินการเหล่านี้ทำให้ LinkedList สามารถใช้เป็นสแต็กคิว (คิว) หรือคิวสองทาง โปรดทราบว่า LinkedList ไม่มีวิธีการซิงโครไนซ์ ทางออกหนึ่งคือการสร้างรายการแบบซิงโครนัสเมื่อสร้างรายการ
รายการ list = collections.synchronizedList (LinkedList ใหม่ (…));
คลาส ArrayList
ArrayList ใช้อาร์เรย์ขนาดตัวแปร ช่วยให้องค์ประกอบทั้งหมดรวมถึง Null ขนาด, isempty, get, set และวิธีการอื่น ๆ กำลังใช้งานได้ แต่ค่าใช้จ่าย Add Method เป็นค่าคงที่ของการแบ่งปัน
แต่ละอินสแตนซ์ ArrayList มีความจุ (ความจุ) เพื่อจัดเก็บขนาดของอาร์เรย์ขององค์ประกอบการจัดเก็บข้อมูล เมื่อต้องแทรกองค์ประกอบจำนวนมากคุณสามารถโทรหาวิธีการตรวจสอบความจุก่อนที่จะแทรกเพื่อเพิ่มความสามารถของ ArrayList เพื่อปรับปรุงประสิทธิภาพการแทรก เช่นเดียวกับ LinkedList, ArrayList ยังเป็นเธรด -Synchronized (unsynchronized)
วิธีหลักที่จัดทำโดย ArrayList:
1. บูลีนเพิ่ม (Object O) เพิ่มองค์ประกอบที่ระบุไปยังส่วนท้ายของรายการ
2. บูลีนเพิ่ม (int indexex, องค์ประกอบวัตถุ) เพื่อระบุตำแหน่งเพื่อเพิ่มองค์ประกอบที่ระบุในรายการ;
3. บูลีน Addall (คอลเลกชัน C) เพิ่มชุดที่ระบุไว้ที่ส่วนท้ายของรายการ
4. บูลีน Addall (int interleg, collection c) เพิ่มคอลเลกชันที่ระบุในตำแหน่งที่ระบุในรายการ;
5. บูลีน Clear () ลบองค์ประกอบทั้งหมดในรายการ
6. boolean clone () กลับไปที่สำเนาของรายการรายการ;
7. บูลีนมี (วัตถุ o) พิจารณาว่ามีองค์ประกอบในรายการหรือไม่
8. บูลีน ensurecapacity (int m) เพิ่มความสามารถของรายการ
9. วัตถุได้รับ (ดัชนี int) ส่งคืนองค์ประกอบที่ระบุในรายการในรายการ;
10. ดัชนีของ (Object Elem) ในรายการค้นหาการเสนอราคาขององค์ประกอบที่ระบุ;
11. ขนาด int () ส่งคืนจำนวนองค์ประกอบของรายการปัจจุบัน
คลาสเวกเตอร์
เวกเตอร์คล้ายกับ ArrayList ความแตกต่างคือเวกเตอร์ถูกซิงโครไนซ์โดยเธรด ตัววนซ้ำที่สร้างขึ้นโดยเวกเตอร์แม้ว่าตัววนซ้ำที่สร้างโดย ArrayList เป็นพอร์ตเดียวกันเนื่องจากเวกเตอร์ถูกซิงโครไนซ์เมื่อมีการสร้างและใช้ตัววนซ้ำหนึ่งเธรดอื่น ๆ เปลี่ยนสถานะของเวกเตอร์ (ตัวอย่างเช่นการเพิ่มหรือลบบางส่วนของบางส่วนของ องค์ประกอบของรัฐ) เมื่อมีการเรียกใช้วิธีการวนซ้ำจะมีการโยนออกไปพร้อมกันเพื่อให้ได้รับการยกเว้นดังนั้นจึงต้องจับข้อยกเว้น
ชั้นเรียนสแต็ก
สแต็คที่สืบทอดมาจากเวกเตอร์และตระหนักถึงสแต็กที่ก้าวหน้าในภายหลัง สแต็คให้วิธีพิเศษ 5 วิธีสำหรับเวกเตอร์ที่จะใช้เป็นสแต็ค นอกเหนือจากวิธีการผลักดันและป๊อปพื้นฐานแล้วยังมีวิธี PEEK เพื่อให้ได้องค์ประกอบของส่วนบนของสแต็กหรือไม่ สแต็ค โปรดทราบว่าหลังจากสแต็กเพิ่งสร้างขึ้นมันเป็นสแต็คที่ว่างเปล่า
ตั้งค่าคลาส
ชุดเป็นคอลเลกชันที่ไม่มีองค์ประกอบซ้ำ ๆ นั่นคือองค์ประกอบสององค์ประกอบ E1 และ E2 มี e1.equals (e2) = false มีองค์ประกอบ Null ที่ตั้งค่ามากที่สุด เห็นได้ชัดว่าตัวสร้างของชุดมีเงื่อนไขข้อ จำกัด และอินพุตของพารามิเตอร์การรวบรวมไม่สามารถรวมองค์ประกอบที่ซ้ำกันได้ โปรดทราบว่าคุณต้องใช้วัตถุตัวแปรอย่างระมัดระวังหากองค์ประกอบตัวแปรในชุดเปลี่ยนสถานะสิ่งนี้อาจทำให้เกิดปัญหาบางอย่าง
คลาสแฮช
Hashtable สืบทอดอินเทอร์เฟซแผนที่และใช้ตารางแฮชตามการทำแผนที่ค่าคีย์ วัตถุที่ไม่ใช่ NULL ใด ๆ สามารถใช้เป็นคีย์หรือค่า เพิ่มข้อมูลที่จะใช้ (คีย์, ค่า) และนำข้อมูลออกมาเพื่อใช้ GET (คีย์)
Hashtable ปรับประสิทธิภาพผ่านพารามิเตอร์ทั้งสองของความจุเริ่มต้นและปัจจัยโหลด ปัจจัยการโหลดเริ่มต้น 0.75 ดีขึ้นได้รับความสมดุลของเวลาและพื้นที่ การเพิ่มปัจจัยโหลดสามารถประหยัดพื้นที่ได้ แต่เวลาการค้นหาที่สอดคล้องกันจะเพิ่มขึ้นซึ่งจะส่งผลกระทบต่อการดำเนินงานเช่น Get and Put ใช้ตัวอย่างง่ายๆของการแฮชช์เพื่อวางตัวเลขสามตัวของ 1, 2 และ 3 ในแฮชช์
รายการ 2. ตัวอย่างแฮช
Hashtable Numbers = new hashtable (); numbers.put (“ หนึ่ง”, จำนวนเต็มใหม่ (1)); numbers.put (“ สอง”, จำนวนเต็มใหม่ (2)); numbers.put (“ สาม”, จำนวนเต็มใหม่ (3 );
หากเราต้องการนำตัวเลขออกมาเช่น 2 เราสามารถใช้คีย์ที่เกี่ยวข้องเพื่อนำออกมาและรหัสจะแสดงในรายการ 3
รายการ 3. อ่านข้อมูลจาก Hastable
จำนวนเต็ม n = (จำนวนเต็ม) numbers.get ("สอง");เนื่องจากวัตถุของคีย์จะถูกกำหนดโดยการคำนวณฟังก์ชั่นการแจกแจงเพื่อกำหนดตำแหน่งของค่าที่สอดคล้องกันวัตถุใด ๆ ที่เป็นคีย์จะต้องใช้วิธี HashCode และ Equals วิธีการ HashCode และ Equals สืบทอดวัตถุรูท = จริงแล้ว HashCode ของพวกเขาจะต้องเหมือนกัน แต่ถ้าวัตถุทั้งสองนั้นแตกต่างกัน HashCode ของพวกเขาไม่จำเป็นต้องแตกต่างกัน วิธีการ HashCode () ที่สามารถเร่งการทำงานของตารางแฮช
หากวัตถุเดียวกันมี hashcode ที่แตกต่างกันจะมีผลลัพธ์ที่ไม่คาดคิดสำหรับการทำงานของตารางแฮช (รอคอยที่จะคืนค่า null) แทนที่จะเขียนเพียงหนึ่งในนั้น
คลาส hashmap
HashMap นั้นคล้ายคลึงกับ Hashtable อย่างไรก็ตามเมื่อ HASHMAP ถือเป็นวิธีการรวบรวม (ค่า () สามารถส่งคืนได้) มันเป็นสัดส่วนกับค่าใช้จ่ายในการทำซ้ำแบบซ้ำ ๆ และความสามารถของ HASHMAP ดังนั้นหากประสิทธิภาพของการดำเนินการวนซ้ำมีความสำคัญมากอย่าตั้งค่าความสามารถในการเริ่มต้นของ HASHMAP สูงเกินไปหรือตั้งค่าต่ำเกินไปในพารามิเตอร์โหลดปัจจัย
ระดับความอ่อนแอ
WeakhashMap เป็น Hashmap ที่ได้รับการปรับปรุงว่า "การอ้างอิงที่อ่อนแอ" สำหรับคีย์
การฝึกฝนคลาสคอลเลกชัน
ArrayList, Vector และ LinkedList ถูกนำมาใช้ทั้งหมดจาก AbstractList และ AbstractList ใช้อินเทอร์เฟซรายการโดยตรงและขยายจาก AbstarctCollection ArrayList และ Vector ใช้อาร์เรย์เพื่อนำไปใช้ LinkedList ใช้โครงสร้างข้อมูลที่เชื่อมโยงสองเวย์แบบวงกลมซึ่งเชื่อมต่อกันด้วยชุดของรายการตาราง
เมื่อความต้องการความจุของ ArrayList เกินขนาดของอาร์เรย์ปัจจุบันจะต้องมีการขยาย ในระหว่างกระบวนการขยายกำลังการผลิตจะมีการดำเนินการจำลองแบบอาร์เรย์จำนวนมากและเมื่อมีการทำซ้ำอาร์เรย์วิธีการ system.arraycopy () จะถูกเรียกในที่สุด เนื่องจาก LinkedList ใช้โครงสร้างของรายการที่เชื่อมโยงจึงไม่จำเป็นต้องรักษาขนาดของความสามารถ เนื่องจากความต่อเนื่องของอาร์เรย์เมื่อองค์ประกอบเพิ่มขึ้นเสมอในตอนท้ายการขยายอาเรย์และการจำลองแบบอาเรย์สามารถสร้างขึ้นได้ก็ต่อเมื่อพื้นที่ไม่เพียงพอ
ArrayList ขึ้นอยู่กับอาร์เรย์และอาร์เรย์เป็นพื้นที่หน่วยความจำอย่างต่อเนื่อง LinkedList ไม่ลดประสิทธิภาพเนื่องจากการแทรกข้อมูล
แต่ละองค์ประกอบที่มีประสิทธิภาพของ ArrayList จะต้องได้รับการจัดระเบียบใหม่หลังจากลบการดำเนินการและการกำหนดตำแหน่งของตำแหน่งองค์ประกอบที่ถูกลบยิ่งสูงขึ้นค่าใช้จ่ายที่สูงขึ้นในระหว่างการปรับโครงสร้างอาร์เรย์ LinkedList จำเป็นต้องลบข้อมูลกลางสำหรับครึ่งรายการ
รายการ 4. ArrayList และ LinkedList ใช้รหัส
นำเข้า java.util.arraylist; นำเข้า java.util.linkedlist; = วัตถุใหม่ (); m. (); System.out.println (end-start); 0, OBJ2); 1000; i ++) {list1.add (obj1);} end = system.currentttimemillis (); System.currentttimemillis (); ;}}รายการ 5. รันเอาต์พุต
639129669690015
HashMap คือการสร้างอัลกอริทึมคีย์จากนั้นแมปค่าแฮชกับที่อยู่หน่วยความจำเพื่อรับข้อมูลที่สอดคล้องกับคีย์โดยตรง ใน HashMap โครงสร้างข้อมูลพื้นฐานใช้อาร์เรย์ที่อยู่หน่วยความจำที่เรียกว่าเป็นดัชนีฉลากของอาร์เรย์ ประสิทธิภาพสูงของ HashMap ต้องการประเด็นต่อไปนี้:
1. อัลกอริทึมแฮชจะต้องมีประสิทธิภาพ
2. อัลกอริทึมของค่าแฮชไปยังที่อยู่หน่วยความจำ (ดัชนีอาร์เรย์) นั้นรวดเร็ว
3. ตามที่อยู่หน่วยความจำ (ดัชนีอาร์เรย์) คุณสามารถรับค่าที่สอดคล้องกันได้โดยตรง
HashMap เป็นอาร์เรย์ของรายการที่เชื่อมโยง ดังที่ได้กล่าวไว้ก่อนหน้านี้กลไกการใช้งานตามวิธีการที่เชื่อมโยงกับวิธีการ HashMap ตราบใดที่วิธีการ hashcode () และ hash () นั้นทำได้เพียงพอที่จะลดความขัดแย้งที่เกิดขึ้นได้มากที่สุดเท่าที่จะเป็นไปได้ เกือบจะเทียบเท่ากับการเข้าถึงอาร์เรย์แบบสุ่ม อย่างไรก็ตามหากวิธีการ hashcode () หรือ hash () ประสบความสำเร็จไม่ดีในกรณีของความขัดแย้งจำนวนมาก HashMap จะถูกลดระดับลงในรายการที่เชื่อมโยงหลายรายการซึ่งเทียบเท่ากับรายการที่เชื่อมโยงสำหรับการทำงานของ HashMap คราวนี้การแสดงแย่มาก
ข้อเสียในการทำงานของ HashMap คือความผิดปกติซึ่งเก็บไว้ในองค์ประกอบใน HashMap หากคุณต้องการเก็บคำสั่งอินพุตคุณสามารถใช้ LinkedHashMap แทน
LinkedHashMap สืบทอดมาจาก HASHMAP และมีประสิทธิภาพสูง
HashMap สามารถใช้งาน Put () และ Get () ได้เร็วเท่ากับอัลกอริทึมแฮช TreeMap จัดเตรียมการใช้งานแผนที่ที่แตกต่างอย่างสิ้นเชิง ในแง่ของฟังก์ชั่น Treemap มีคุณสมบัติที่ทรงพลังกว่า HashMap ประสิทธิภาพของ Treemap ต่ำกว่า HashMap เล็กน้อย หากคุณต้องการเรียงลำดับองค์ประกอบในการพัฒนาคุณไม่สามารถใช้ฟังก์ชั่นนี้ด้วย HashMap LinkedHashMap ขึ้นอยู่กับลำดับขององค์ประกอบที่เข้าสู่คอลเลกชันหรือลำดับของการเข้าถึง
LinkedHashMap ถูกจัดเรียงตามลำดับของการเพิ่มองค์ประกอบหรือการเข้าถึงในขณะที่ treemap ถูกเรียงลำดับตามคีย์ขององค์ประกอบ
รายการ 6 แสดงให้เห็นว่ารหัสแสดงให้เห็นถึงลำดับของตรรกะทางธุรกิจโดยใช้ treemap
รายการ 6. Treemap ใช้การเรียงลำดับ
นำเข้า Java.util.iterator; ชื่อ; this.score = score;} @ouverride // บอก treemap วิธีการเรียงลำดับ int publicto (นักเรียน o) {// วิธีการที่ถูกสร้างขึ้นใหม่ (O.Score <this.sc หรือ) (O.Score> this.score) {return -1;} return 0;} @overridepublic String toString () {StringBuffer SB = ใหม่ StringBuffer (); SB.Append ("); (); นักเรียน S1 = นักเรียนใหม่ ("1", 100); นักเรียน S2 = นักเรียนใหม่ ("2", 99); นักเรียน S3 = นักเรียนใหม่ ("3", 97); นักเรียน S4 = นักเรียนใหม่ ("4 ", 91); map.put (S1, ใหม่ studentDetailInfo (S1)); map.put (S2, นักศึกษาใหม่ DETALINFO (S2)); map.put (S3, นักศึกษาใหม่ DetailInfo (S3)); S4, ใหม่ ); ถัดไป (); System.out.println (คีย์+"->"+map.get (คีย์));} system.out.println ("" soppap end "); // map1 = (timemap) แผนที่) (S1); (คีย์));} System.out.println ("Soppap End"); ;) {คีย์นักเรียน = (นักเรียน) itrator (นักเรียน s) {this.s = s;}@ounridepublic สตริง toString () {return s.name + "ข้อมูลรายละเอียด" ของ ";}}รายการ 7. รันเอาต์พุต
ชื่อ: 4 คะแนน: 91-> ข้อมูลรายละเอียด 4 ชื่อ: 3 คะแนน: 97-> ข้อมูลรายละเอียด 3 ของข้อมูลรายละเอียด endname: 4 คะแนน: 91-> ข้อมูลรายละเอียด 4 ของข้อมูล: 3 คะแนน: 97-> ข้อมูลรายละเอียดของข้อมูล: 2 คะแนน: 99- > ข้อมูลรายละเอียด 2 ของ 2 ข้อมูลที่สิ้นสุด: 1 คะแนน: 100-> ข้อมูลรายละเอียดของ 1 ข้อมูล
WeakhashMap มีลักษณะเฉพาะเองว่าหากไม่มีสิ่งอื่นใดในคีย์นี้ยกเว้นการอ้างอิงของมันแผนที่นี้จะยกเลิกค่าโดยอัตโนมัติ ดังที่แสดงในรายการ 8 รหัสแสดงวัตถุแผนที่สองชิ้นหนึ่งคือ HashMap และอีกอันคือ WeakhashMap ในเวลาเดียวกัน Null พวกเขาชี้ไปที่ Null เหตุผลสำหรับสถานการณ์นี้คือสำหรับวัตถุ A เมื่อ HASHMAP ถูกลบและ A ถึง NULL นอกเหนือจากความอ่อนแอ hASHMAP ไม่มีตัวชี้ไปที่ A ยกเว้น A ถึงแม้ว่าจะชี้ไปที่ NULL จะรักษาวัตถุ B
รายการ 8.WEAKHASHMAP รหัสตัวอย่าง
นำเข้า java.util.hashmap; นำเข้า java.util.itrator; สตริง ("); , B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, "BBB"); "BBB"); .ENTRY EN = (map.entry) izext (); . iterator (); +en.getValue ());รายการ 9. รันเอาท์พุท
แผนที่: B: BBBWEAKMAP: B: BBB
WeakhashMap ส่วนใหญ่บรรลุวัตถุประสงค์ในการลบรายการที่ไม่ได้ใช้ภายในผ่าน expungestaleentries ซึ่งจะบรรลุวัตถุประสงค์ของการปล่อยหน่วยความจำโดยอัตโนมัติ โดยพื้นฐานแล้วตราบใดที่มีการเข้าถึงเนื้อหาของ WeakHashMap ฟังก์ชั่นนี้จะถูกเรียกให้บรรลุรายการภายในที่ไม่ได้อ้างอิงอีกต่อไป แต่ถ้าคุณกลายเป็นคนอ่อนแอและก่อน GC คุณไม่เคยไปเยี่ยมชม weakhashmap มันไม่ จำกัด ที่จะปล่อยหน่วยความจำหรือไม่?
รายการ 10. WeakhashMaptest1
นำเข้า java.util.arraylist; นำเข้า java.util.list นำเข้า java.util.weakhashmap; ] [] >> แผนที่ = arraylist ใหม่ <beakhashmap <byte [] [], byte [] [] >> (); ไบต์ [] []> d = new beakhashmap <byte [] [], byte [] []> (); .Add (D);
อย่าเปลี่ยนพารามิเตอร์ JVM ใด ๆ ที่ทำงานอยู่ 10 รายการที่แสดงในรายการการดำเนินการ
รายการ 11. รันเอาต์พุต
241242243Excetion ในด้าย "หลัก" java.lang.outofmemoryError: java heap spaceat weakhashmaptest1.main (beakhashmapst1.java:10)
แน่นอนว่า WeakhashMap ไม่ได้ปล่อยหน่วยความจำที่ไม่จำเป็นโดยอัตโนมัติในเวลานี้ รหัสที่แสดงในรายการ 12 จะไม่มีหน่วยความจำล้น
รายการ 12. WeakhashMaptest2
นำเข้า java.util.arraylist; นำเข้า Java.util.list; ] [] >> แผนที่ = arraylist ใหม่ <beakhashmap <byte [] [], byte [] [] >> (); ไบต์ [] []> d = new beakhashmap <byte [] [], byte [] []> (); .Add (D); .get (j) .size ());}}}}
ผลลัพธ์ของการดำเนินการพบว่าเอาต์พุตการทดสอบเป็นเรื่องปกติและปัญหาของการล้นหน่วยความจำไม่เกิดขึ้นอีกต่อไป
โดยทั่วไปแล้ว WeakhashMap ไม่ใช่วัตถุที่ไม่ได้ใช้ภายในหากคุณทำอะไร แต่ปล่อยวัตถุที่ไม่ได้ใช้ภายในเมื่อคุณเข้าถึง
WeakHashMap ใช้การอ้างอิงที่อ่อนแอเนื่องจากรายการ <k, v> ได้รับการสืบทอดจาก Weakreference <k>
ในคำจำกัดความของคลาสและตัวสร้างของรายการที่อ่อนแอ $ hashmap <k, v>, จะแสดงในรายการ 13
รายการ 13. นิยามคลาส BEATHASHMAP
รายการคลาสสแตติกส่วนตัว <k, v> ขยาย beakreference <k> ใช้ map.entry <k, v> รายการ (k key, v value, referencequeue <k> คิว, int hash, รายการ <k, v> ถัดไป) {super super (คีย์, คิว);โปรดทราบว่ามันสร้างคำสั่งพ่อ -คลาส: "Super (คีย์, คิว);"; ใน System.gc () อาร์เรย์ไบต์ในคีย์จะถูกรีไซเคิลและค่ายังคงอยู่ (ค่ามีความสัมพันธ์อย่างมากกับรายการรายการเชื่อมโยงในแผนที่และแผนที่เชื่อมโยงใน ArrayList)
ทุกครั้งที่ฉันมี weakhashmap ใหม่ทุกครั้งหลังจากการดำเนินการวางแม้ว่า GC จะรีไซเคิลอาร์เรย์ไบต์ในคีย์ที่อ่อนแอและแจ้งเหตุการณ์ให้อ้างอิงถึงการอ้างอิงไม่มีการกระทำที่สอดคล้องกัน คีย์ยังคงมีอยู่ใน WeakhashMap และค่าที่สอดคล้องกันก็มีอยู่
เมื่อใดที่ค่าถูกล้างออก? ? ตรวจสอบซอร์สโค้ดที่อ่อนแอ ดังนั้นเอฟเฟกต์คือคีย์ถูกล้างเมื่อ GC และค่าเข้าเยี่ยมชม beakhashmap หลังจากล้างคีย์
คลาส WeakhashMap นั้นไม่ได้เป็นแบบไม่ใช้ ดังนั้นไม่ว่าจะอยู่ในการแมปหรือนอกการแมปคีย์จะถูกลบออกโดยอัตโนมัติหลังจากที่ Recyler ขยะจะลบการอ้างอิงที่อ่อนแอไปยังคีย์ที่แน่นอน ควรสังเกตว่าวัตถุค่าใน WeakHashMap นั้นถูกเก็บไว้โดยการดึงดูดทั่วไป ดังนั้นคุณควรระมัดระวังเพื่อให้แน่ใจว่าวัตถุค่าจะไม่อ้างอิงทั้งโดยตรงหรือโดยอ้อมเพราะนี่จะช่วยป้องกันไม่ให้เกิดความตึงเครียดจากการทิ้ง โปรดทราบว่าวัตถุค่าสามารถอ้างอิงคีย์ที่สอดคล้องกันผ่านทางอ้อมผ่านทางอ่อนแอซึ่งหมายความว่าวัตถุค่าที่แน่นอนอาจถูกอ้างอิงอย่างมากโดยวัตถุคีย์อื่น ๆ และวัตถุค่าที่เกี่ยวข้องกับวัตถุคีย์จะเปลี่ยนเป็นชิ้นแรก หนึ่ง
วิธีหนึ่งในการจัดการกับปัญหานี้คือการเก็บค่าตัวเองใน beakreferentes ก่อนที่จะแทรกเช่น: m.put (คีย์, new weakreference (ค่า)) จากนั้นใช้การผ่า "อุปกรณ์สำรองล้มเหลวอย่างรวดเร็วหลังจากที่อุปกรณ์วนซ้ำถูกสร้างขึ้นหากการแมปถูกแก้ไขจากโครงสร้างเว้นแต่จะมีการลบหรือเพิ่มวิธีการของตัววนซ้ำตัววนซ้ำจะได้รับการแก้ไขในเวลาใดก็ได้ โยนการแก้ไขพร้อมกัน Exception ดังนั้นเมื่อเผชิญกับการปรับเปลี่ยนพร้อมกันผู้วนซ้ำก็ล้มเหลวอย่างรวดเร็วอย่างสมบูรณ์แทนที่จะเสี่ยงต่อพฤติกรรมที่ไม่แน่นอนโดยพลการตลอดเวลาในอนาคต
โปรดทราบว่าเราไม่สามารถมั่นใจได้ว่าตัววนซ้ำล้มเหลว
เพื่อสรุปการแนะนำและรหัสอินสแตนซ์ในการครอบคลุมก่อนหน้านี้เราสามารถรู้ได้ว่าหากเกี่ยวข้องกับสแต็กคิว ฯลฯ เราควรพิจารณาใช้รายการ สำหรับการดำเนินการเช่นการแทรกอย่างรวดเร็วและองค์ประกอบการลบควรใช้ LinkedList หากคุณต้องการเข้าถึงองค์ประกอบอย่างรวดเร็วคุณควรใช้ ArrayList หากโปรแกรมดำเนินการในสภาพแวดล้อมแบบเธรดเดี่ยวหรือการเข้าถึงในเธรดเดียวเท่านั้นโดยพิจารณาจากคลาสที่ไม่ใช่แบบไม่ทำมันจะมีประสิทธิภาพ หากหลายเธรดอาจใช้งานคลาสในเวลาเดียวกันควรใช้คลาสซิงโครนัส ให้ความสนใจเป็นพิเศษกับการดำเนินการของตารางแฮชและวัตถุของเท่ากับและแฮชโค้ดเป็นคีย์คือการเขียนวิธีการเท่ากับและ hashcode อย่างถูกต้อง พยายามส่งคืนอินเทอร์เฟซแทนประเภทจริงเช่นรายการที่ส่งคืนแทน arraylist ดังนั้นหาก arraylist จำเป็นต้องถูกแทนที่ด้วย LinkedList ในอนาคตรหัสลูกค้าไม่จำเป็นต้องเปลี่ยน
บทความนี้มีไว้สำหรับการแบ่งปันระดับแอปพลิเคชันเท่านั้น