โดยทั่วไปแล้วโครงสร้างข้อมูลในตำราเรียนรวมถึงอาร์เรย์รายการที่เชื่อมโยงเดี่ยวสแต็คต้นไม้และกราฟ โครงสร้างข้อมูลที่ฉันอ้างถึงที่นี่เป็นคำถามของวิธีการแสดงวัตถุ บางครั้งการประกาศตัวแปรเดียวนั้นไร้ประโยชน์เช่น Int, String, Double, Double หรือแม้แต่ One-Mimensional Array และอาร์เรย์สองมิติไม่สามารถแสดงสิ่งที่คุณต้องการแสดงได้อย่างเต็มที่และมันลำบากเกินไปที่จะกำหนดคลาส ในเวลานี้คุณสามารถพิจารณาใช้คลาสคอลเลกชันใน Java การใช้คลาสคอลเลกชันคุณต้องประกาศนำเข้า java.util.* ในส่วนหัวไฟล์
1. ไดนามิกสั่งซื้อขนาดตัวแปรหนึ่งมิติเวกเตอร์และ ArrayList
คลาสคอลเลกชัน รวมถึงไดนามิกการสั่งซื้อขนาดตัวแปรเวกเตอร์อาร์เรย์หนึ่งมิติและ ArrayList
ความแตกต่างเพียงอย่างเดียวระหว่างเวกเตอร์และอาร์เรย์ลิสต์คือ: เวกเตอร์มาพร้อมกับเธรดพิเศษร่วมกันและหลายเธรดจะโยนข้อยกเว้นเพื่ออ่านและเขียนในขณะที่ ArrayList อนุญาตให้หลายเธรดอ่านและเขียนและส่วนอื่น ๆ ก็เหมือนกัน กล่าวอีกนัยหนึ่งถ้าเธรดเดียวกำลังอ่านและเขียนไม่มีความแตกต่างระหว่างการใช้เวกเตอร์และอาร์เรย์ลิสต์ แต่ตอนนี้การเขียนโปรแกรมเป็นอาร์เรย์โดยทั่วไปและการใช้เวกเตอร์นั้นไม่ใช่กระแสหลักเล็กน้อย
1. การใช้เวกเตอร์มีดังนี้:
Void Vectortest () {// Vector <bector> หมายความว่าเวกเตอร์นี้สามารถเก็บ double // vector <string> หมายความว่าเวกเตอร์นี้สามารถเก็บสตริง // แม้ว่าเวกเตอร์ <Ojrop> เวกเตอร์ = เวกเตอร์ใหม่ <Ojuct> (); เทียบเท่ากับเวกเตอร์เวกเตอร์ = new // vector (); อย่างไรก็ตามการเขียนสิ่งนี้ใน eclipse จะเตือนคุณโดยระบุว่าเวกเตอร์ของคุณไม่ได้มาตรฐาน () เวกเตอร์ <Ojrop> เวกเตอร์ = เวกเตอร์ใหม่ <Ojrop> (); vector.add (1.6); vector.add (2.06); vector.add (1); System.out.println ("การเพิ่มอย่างง่ายหมายถึงการเพิ่มองค์ประกอบจากจุดสิ้นสุด:" + เวกเตอร์); System.out.println ("size () สามารถค้นหาจำนวนองค์ประกอบที่มีอยู่ในเวกเตอร์:" + vector.size ()); vector.remove (1); System.out.println ("ลบ (1) หมายถึงการลบองค์ประกอบแรกเนื่องจากการนับเริ่มต้นจาก 0 นั่นคือองค์ประกอบ 2.06:" + เวกเตอร์); vector.remove (vector.lastelement ()); System.out.println ("เวกเตอร์ที่ลบองค์ประกอบสุดท้ายคือ:" + เวกเตอร์); vector.add (0, 1.8888); System.out.println ("เพิ่ม 1.8888 องค์ประกอบนี้ที่ตำแหน่ง 0:" + เวกเตอร์); vector.set (0, "a"); System.out.println ("เปลี่ยนตำแหน่งที่ 0:" + เวกเตอร์); - หากวิธีนี้เรียกในฟังก์ชันหลัก:
System.out.println ("======== การทดสอบเริ่มต้นของโครงสร้างข้อมูลเวกเตอร์ ==========="); vectortest (); System.out.println ("======== การทดสอบสิ้นสุดโครงสร้างข้อมูลเวกเตอร์ ==============); ผลการดำเนินการมีดังนี้:
======= การทดสอบเริ่มต้นของโครงสร้างข้อมูลเวกเตอร์ =======
การเพิ่มอย่างง่ายหมายถึงการเพิ่มองค์ประกอบจากจุดสิ้นสุด: [1.6, 2.06, 1]
ขนาด () สามารถค้นหาจำนวนองค์ประกอบที่มีอยู่ในเวกเตอร์: 3
ลบ (1) หมายถึงการลบองค์ประกอบแรก เนื่องจากการนับเริ่มต้นจาก 0 นั่นคือองค์ประกอบ 2.06: [1.6, 1]
เวกเตอร์ที่ลบองค์ประกอบสุดท้ายคือ: [1.6]
เพิ่มองค์ประกอบ 1.8888 ที่ตำแหน่งที่ 0: [1.8888, 1.6]
เปลี่ยนองค์ประกอบที่ตำแหน่งที่ 0 เป็น: [a, 1.6]
======== สิ้นสุดการทดสอบโครงสร้างข้อมูลเวกเตอร์ =======
2. ArrayList
โมฆะคงที่สาธารณะ arraylistTest () {arrayList <bould> arrayList = new ArrayList <bouly> (); arraylist.add (1.0); arraylist.add (4.0); arraylist.add (5.0); arraylist.add (2.3); System.out.println ("การเพิ่มอย่างง่ายหมายถึงการเพิ่มองค์ประกอบจากจุดสิ้นสุด:" + arraylist); System.out.println ("size () สามารถค้นหาจำนวนองค์ประกอบที่มีอยู่:" + arraylist.size ()); arraylist.remove (1); System.out.println ("ลบ (1) หมายถึงการลบองค์ประกอบแรกเนื่องจากการนับเริ่มต้นจาก 0 นั่นคือองค์ประกอบ 4:" + arraylist); arraylist.remove (arraylist.size () - 1); System.out.println ("arraylist สำหรับการลบองค์ประกอบสุดท้ายคือ:" + arraylist); arraylist.add (0, 1.8888); System.out.println ("เพิ่มองค์ประกอบ 1.8888 ที่ตำแหน่ง 0:" + ArrayList); arraylist.set (0, 9.0); System.out.println ("เปลี่ยนองค์ประกอบที่ตำแหน่ง 0 เป็น:" + ArrayList); collections.sort (arraylist); System.out.println ("การเรียงลำดับได้รับการสนับสนุนหาก ArrayList ไม่ใช่ประเภทนามธรรม" + ArrayList); - ที่นี่คุณจะเห็นว่าวิธีที่ ArrayList ลบองค์ประกอบสุดท้ายนั้นแตกต่างจากเวกเตอร์ เหตุผลหลักคือ ArrayList ไม่มีวิธี LastElement () เพื่อลบองค์ประกอบสุดท้าย ลบ () สามารถใช้เพื่อกำหนดตำแหน่งขององค์ประกอบสุดท้ายเท่านั้น หากวิธีนี้เรียกในฟังก์ชันหลักเช่นนี้:
System.out.println ("========= การทดสอบเริ่มต้นของโครงสร้างข้อมูล ArrayList ========="); arraylisttest (); System.out.println ("======== การทดสอบสิ้นสุดโครงสร้างข้อมูล ArrayList ==================); จากนั้นจะได้รับผลการดำเนินการต่อไปนี้:
======= การทดสอบเริ่มต้นของโครงสร้างข้อมูล ArrayList ======
การเพิ่มอย่างง่ายหมายถึงการเพิ่มองค์ประกอบจากจุดสิ้นสุด: [1.0, 4.0, 5.0, 2.3]
ขนาด () สามารถค้นหาจำนวนองค์ประกอบที่มีอยู่: 4
ลบ (1) หมายถึงการลบองค์ประกอบแรก เนื่องจากการนับเริ่มต้นจาก 0 นั่นคือองค์ประกอบ 4: [1.0, 5.0, 2.3]
ArrayList สำหรับการลบองค์ประกอบสุดท้ายคือ: [1.0, 5.0]
เพิ่มองค์ประกอบ 1.8888 ที่ตำแหน่งที่ 0: [1.8888, 1.0, 5.0]
เปลี่ยนองค์ประกอบที่ตำแหน่งที่ 0 เป็น: [9.0, 1.0, 5.0]
หาก ArrayList ไม่ใช่ประเภทนามธรรมการเรียงลำดับจะได้รับการสนับสนุน [1.0, 5.0, 9.0]
======== สิ้นสุดการทดสอบโครงสร้างข้อมูล ArrayList =======
จากสองตัวอย่างข้างต้นเราจะเห็นว่าเวกเตอร์และ arraylist เป็นมากกว่าอาร์เรย์ทั่วไปนั่นคืออาร์เรย์หนึ่งมิติที่สอนในตำราเรียน int array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; มันมีพลังมากขึ้น คุณสามารถแทรกองค์ประกอบที่ตำแหน่งใด ๆ หรือคุณสามารถลบองค์ประกอบที่ตำแหน่งที่กำหนดโดยไม่ต้องข้ามอาร์เรย์ แน่นอนคุณยังต้องรู้ว่าอาร์เรย์นี้ถูกสำรวจเพื่อคุณอย่างไร ในความเป็นจริง ArrayList และอาร์เรย์หนึ่งมิติธรรมดาสามารถเปลี่ยนได้อย่างสมบูรณ์และ ArrayList ยังสามารถใช้ในการเรียงลำดับอาร์เรย์โดยตรงโดยไม่ต้องเขียนการเรียงลำดับฟองบนอาร์เรย์ คุณสามารถเรียงลำดับอาร์เรย์ได้โดยตรงด้วย collections.sort (); จากนั้นใช้ collections.reverse (); เพื่อให้บรรลุการเรียงลำดับแบบผกผัน แน่นอนว่ามันยังคงเป็นประโยคเดียวกัน สำหรับคุณคุณยังต้องรู้ว่าอาร์เรย์นี้จัดเรียงอย่างไร
ตัวอย่างเช่นวิธีการต่อไปนี้ใช้การเรียงลำดับและการเรียงลำดับผกผันของอาร์เรย์ int หนึ่งมิติ [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; ก่อนที่จะแปลงอาร์เรย์เป็น ArrayList จากนั้นจัดเรียงด้วย collections.sort (); และคอลเลกชัน reverse ();, และในที่สุดก็แปลงเนื้อหา ArrayList กลับเป็นอาร์เรย์หนึ่งมิติ:
โมฆะคงที่สาธารณะ arraylistort () {int array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; ArrayList <Integer> arrayList = new ArrayList <integer> (); สำหรับ (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); สำหรับ (int i = 0; i <array.length; i ++) arraylist.add (อาร์เรย์ [i]); collections.sort (arraylist); สำหรับ (int i = 0; i <array.length; i ++) arraylist.add (อาร์เรย์ [i]); collections.sort (arraylist); สำหรับ (int i = 0; i <array.length; i <array.length; i ++) arraylist.add (อาร์เรย์ [i]); collections.sort (arraylist); สำหรับ (int i = 0; i <array.length; i <array.length; i ++) arraylist.add (อาร์เรย์ [i]); collections.sort (arraylist); สำหรับ (int i = 0; i <array.length; i ++) อาร์เรย์ [i] = arraylist.get (i); System.out.print ("เรียงลำดับอาร์เรย์:"); สำหรับ (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); คอลเลคชั่น Reverse (ArrayList); สำหรับ (int i = 0; i <array.length; i ++) อาร์เรย์ [i] = arraylist.get (i); System.out.print ("อาร์เรย์เรียงลำดับแบบผกผัน:"); สำหรับ (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); // ทำลาย ArrayList หลังจากการเรียงลำดับ arrayList = null; // ประโยคนี้แสดงให้เห็นว่า Java รีไซเคิลขยะทันที แน่นอนไม่ว่าประโยคนี้จะโอเคหรือไม่ Java จะลบขยะโดยอัตโนมัติในระหว่างกระบวนการรัน - ในฟังก์ชั่นหลักวิธีนี้เรียกเช่นนี้:
System.out.println ("=========== การเรียงลำดับ java array เริ่มต้น =========="); arraylistort (); System.out.println ("============== การเรียงลำดับอาร์เรย์ Java สิ้นสุด ===========); คุณสามารถรับผลการทำงานต่อไปนี้:
======== การเรียงลำดับการเรียงลำดับ Java เริ่มต้น =======
8,7,100,88,6,4,5,33,7, จัดเรียงอาร์เรย์: 4,5,6,7,7,8,33,88,100, เรียงลำดับแบบผกผัน: 100,88,33,8,7,7,6,5,5,4
========= การเรียงลำดับจาวาอาร์เรย์สิ้นสุด =======
นอกจากนี้ยังเป็นจริงสำหรับ "การแนะนำสั้น ๆ เกี่ยวกับการใช้รายการใน Java" (คลิกเพื่อเปิดลิงค์)
2. คอลเลกชัน Hashset
นอกจากนี้ยังมีคอลเล็กชั่น HashSet ซึ่งเหมือนกับแนวคิดการรวบรวมทางคณิตศาสตร์ ชุดที่ประกอบด้วยองค์ประกอบหนึ่งหรือมากกว่านั้นเรียกว่าชุด Hashset มี:
1. การกำหนด องค์ประกอบในชุดจะต้องกำหนด นี่เป็นเรื่องไร้สาระ มันจะต้องกำหนด ฉันยังสามารถใส่สิ่งที่ไม่แน่นอนได้หรือไม่?
2. เพศตรงข้ามซึ่งกันและกัน องค์ประกอบในชุดแตกต่างกัน ตัวอย่างเช่น: ตั้งค่า A = {1, A} ดังนั้น A ไม่สามารถเท่ากับ 1 นั่นคือถ้าคุณใส่ 1S สองตัวลงใน HashSet มันจะกลายเป็น 1 โดยอัตโนมัติโดยอัตโนมัติ
3. ความผิดปกติ ไม่มีลำดับขององค์ประกอบในชุด ดังนั้น HashSet จะต้องไม่ดำเนินการเรียงลำดับการดำเนินการเช่นวิธีการต่อไปนี้:
โมฆะคงที่สาธารณะ hashSetTest () {HashSet <Ojrop> HASHSET = ใหม่ HashSet <Ojuct> (); hashset.add (1); hashset.add (1); hashset.add (5); hashset.add (2.3); System.out.println ("การเพิ่มอย่างง่ายหมายถึงการเพิ่มองค์ประกอบจากจุดสิ้นสุด:" + hashset); System.out.println ("size () สามารถค้นหาจำนวนองค์ประกอบที่มีอยู่:" + hashset.size ()); hashset.remove (1); System.out.println ("ลบ (1) หมายถึงการลบองค์ประกอบ '1':" + hashset); hashset.remove ("ASD"); System.out.println ("ถ้าไม่มีองค์ประกอบ 'ASD' ลบไม่ทำอะไรเลย:" + HashSet); hashset.add (1.8888); System.out.println ("เพิ่มองค์ประกอบ 1.8888:" + hashset); -ในฟังก์ชั่นหลักโทรหาวิธีนี้:
System.out.println ("========= การทดสอบเริ่มต้นของโครงสร้างข้อมูล HashSet ========="); hashsettest (); System.out.println ("========= สิ้นสุดการทดสอบโครงสร้างข้อมูล HashSet =================); ผลลัพธ์มีดังนี้:
======= การทดสอบเริ่มต้นด้วยโครงสร้างข้อมูล HashSet =======
การเพิ่มอย่างง่ายหมายถึงการเพิ่มองค์ประกอบจากตอนท้าย: [1, 5, 2.3]
ขนาด () สามารถค้นหาจำนวนองค์ประกอบที่มีอยู่: 3
ลบ (1) หมายถึงการลบองค์ประกอบ '1': [5, 2.3]
หากไม่มีองค์ประกอบ 'ASD' ลบไม่ทำอะไรเลย: [5, 2.3]
เพิ่มองค์ประกอบ 1.8888: [5, 1.8888, 2.3]
======== สิ้นสุดการทดสอบโครงสร้างข้อมูล HashSet =======
HashSet มีวิธีการเพิ่ม () และวิธีการลบ () องค์ประกอบที่เพิ่มลงใน Add () อยู่ในลำดับ ผลลัพธ์ที่พิมพ์ด้วย system.out.println () อาจอยู่ในคำสั่งซื้อที่แตกต่างกัน พวกเขาไม่สามารถเหมือนกับเวกเตอร์และอาร์เรย์ลิสต์ด้านบน ตราบใดที่องค์ประกอบที่เก็บไว้ไม่ใช่วัตถุคอลเลคชั่น sort (arraylist); สามารถใช้ในการเรียงลำดับ
3. hashmap คู่
วิธีการใช้งานที่นี่โดยทั่วไปเหมือนกับข้อมูลด้านบนและมันก็ง่ายมาก มันคือการใส่วัตถุลงในแผนที่และสามารถนำวัตถุออกไปในแผนที่ได้ แต่มันผิดที่จะพยายามใช้ไบนารี hashmap เป็นสาม หากวัตถุมีองค์ประกอบมากเกินไปคุณควรพิจารณาใช้คลาส แทนที่จะหมกมุ่นอยู่กับคลาสคอลเลกชันของ Java ที่รบกวนระหว่างตัวแปรทั่วไปและคลาสคลาส
ตัวอย่างเช่นวิธีการต่อไปนี้แสดงการดำเนินการข้อผิดพลาดของการพยายามเปลี่ยน hashmap เป็นสาม:
โมฆะคงที่สาธารณะ maptest () {system.out.println ("============ เริ่มต้นการใช้แผนที่ข้อผิดพลาด ===============); HashMap <String, String> MAP = HASHMAP ใหม่ <สตริง, สตริง> (); สตริง >> (); System.out.println (bigmap.get ("test1") รับ ("key1")); System.out.println (bigmap.get ("test2") รับ ("key2")); ไม่ถูกต้อง =========================================================================================================================================== - - - - - - การเรียกรหัสนี้ในฟังก์ชั่นหลักจะให้ผลการรันต่อไปนี้:
======== การทดสอบเริ่มต้นด้วยโครงสร้างข้อมูลแผนที่ =======
======== เริ่มการใช้งาน MAP Error =======
{test1 = {key2 = 4, key1 = 3}, test2 = {key2 = 4, key1 = 3}}
3
4
3
4
======= สิ้นสุดการใช้งาน MAP Error ======
========= เริ่มต้นการใช้แผนที่ที่ถูกต้อง ======
{key3 = 3, key2 = 2, key1 = 1}
======== สิ้นสุดการใช้แผนที่ที่ถูกต้อง =======
======== สิ้นสุดการทดสอบโครงสร้างข้อมูลแผนที่ =======
โปรแกรมนี้มีวัตถุประสงค์เพื่อให้ชัดเจนมากพยายามสร้าง {test1, key1,1}, {test1, key2,2}, {test2, key3,3}, {test2, key4,4,4}
อย่างไรก็ตาม BigMap ทุกคนยังคงมีแผนที่นั้น เมื่อคุณล้างแผนที่แล้วแผนที่ใน test1 ก็จะถูกล้างด้วย มีคนพยายามสร้าง MAP1, MAP2 หลายตัว ... จากนั้นคุณอาจใช้คลาสที่เรียบง่ายเพื่อดูชัดเจนยิ่งขึ้นและคุณสามารถเขียนวิธีการในชั้นเรียนในอนาคตและสืบทอด
4. หมายเหตุ
เมื่อสร้างเวกเตอร์ใหม่ arraylist, hashset หรือ hashmap คุณสามารถเขียนเป็น:
คอลเลกชัน <String> a = new ArrayList <String> ();
รายการ <String> a = เวกเตอร์ใหม่ <String> ();
เนื่องจากมี ArrayList, Vector, LinkedList, Hashset และ Treeet ที่สืบทอดมาจากอินเทอร์เฟซคอลเลกชันและ HashMap และ Hashtable ที่สืบทอดมาจากอินเตอร์เฟสแผนที่นี่เป็นปัญหาของการสืบทอดการโพลีมอร์ฟิสต์การห่อหุ้มและคลาสอื่น ๆ ใน Java แน่นอนว่าเพื่อให้เพื่อนของคุณดูชัดเจนยิ่งขึ้นอย่าเล่นการตั้งชื่อแฟนซีที่นี่เขียน arraylist ที่ชัดเจน <จำนวนเต็ม> arraylist = arraylist ใหม่ <integer> (); ไม่มีใครกล้าบอกว่าคุณไม่เข้าใจชั้นเรียนใน Java
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น