ตารางเชิงเส้นรายการที่เชื่อมโยงและตารางแฮชเป็นโครงสร้างข้อมูลที่ใช้กันทั่วไป เมื่อพัฒนา Java JDK ได้จัดเตรียมคลาสของคลาสที่สอดคล้องกันเพื่อใช้โครงสร้างข้อมูลพื้นฐาน คลาสเหล่านี้ทั้งหมดอยู่ในแพ็คเกจ Java.util บทความนี้พยายามอธิบายบทบาทของแต่ละชั้นเรียนให้ผู้อ่านและวิธีการใช้อย่างถูกต้องผ่านคำอธิบายง่ายๆ
คอลเลกชัน├List│✜linkedList│✜ArrayList│└ Vector │└stack└setแผนที่├hashtable├hashmap└weakhashmap
อินเทอร์เฟซคอลเลกชัน
คอลเลกชันเป็นอินเทอร์เฟซคอลเลกชันพื้นฐานที่สุด คอลเลกชันแสดงชุดของวัตถุนั่นคือองค์ประกอบของคอลเลกชัน (องค์ประกอบ) คอลเลกชันบางส่วนอนุญาตองค์ประกอบเดียวกันในขณะที่คนอื่นไม่ได้ บางคนสามารถเรียงลำดับได้ แต่คนอื่นไม่สามารถ Java SDK ไม่ได้ให้ชั้นเรียนที่สืบทอดโดยตรงจากคอลเลกชัน คลาสที่จัดทำโดย Java SDK นั้นเป็น "subinterfaces" ทั้งหมดที่สืบทอดมาจากคอลเลกชันเช่นรายการและชุด
คลาสทั้งหมดที่ใช้งานอินเตอร์เฟสคอลเลกชันจะต้องมีตัวสร้างมาตรฐานสองตัว: ตัวสร้างแบบไม่มีพารามิเตอร์ใช้เพื่อสร้างคอลเลกชันที่ว่างเปล่าและตัวสร้างพารามิเตอร์คอลเลกชันใช้เพื่อสร้างคอลเลกชันใหม่ซึ่งมีองค์ประกอบเดียวกับคอลเลกชันที่เข้ามา ตัวสร้างหลังอนุญาตให้ผู้ใช้คัดลอกคอลเลกชัน
จะวนซ้ำทุกองค์ประกอบในคอลเลกชันได้อย่างไร? โดยไม่คำนึงถึงประเภทที่แท้จริงของคอลเลกชันมันรองรับวิธีการวนซ้ำ () ซึ่งส่งคืนตัววนซ้ำและใช้ตัววนซ้ำนี้เพื่อเข้าถึงแต่ละองค์ประกอบในคอลเลกชันทีละตัว
ประเพณีทั่วไปมีดังนี้:
ตัววนซ้ำมัน = collection.iterator (); // รับตัววนซ้ำในขณะที่ (it.hasnext ()) {object obj = it.next (); // รับองค์ประกอบถัดไป} อินเทอร์เฟซทั้งสองที่ได้จากอินเทอร์เฟซคอลเลกชันคือรายการและตั้งค่า
รายการอินเทอร์เฟซ
รายการเป็นคอลเลกชันที่สั่งซื้อและการใช้อินเทอร์เฟซนี้ช่วยให้คุณสามารถควบคุมตำแหน่งของการแทรกองค์ประกอบแต่ละอย่างได้อย่างแม่นยำ ผู้ใช้สามารถใช้ดัชนี (ตำแหน่งขององค์ประกอบในรายการคล้ายกับตัวห้อยอาร์เรย์) เพื่อเข้าถึงองค์ประกอบในรายการซึ่งคล้ายกับอาร์เรย์ของ Java
ไม่เหมือนกับชุดที่กล่าวถึงด้านล่างรายการอนุญาตองค์ประกอบเดียวกัน
นอกเหนือจากเมธอด iterator () ที่มีเมธอด iterator () ที่จำเป็นรายการยังมีวิธีการ listiterator () ซึ่งส่งคืนอินเตอร์เฟส listiterator เมื่อเปรียบเทียบกับอินเทอร์เฟซ Iterator Standard listiterator มีวิธีการเพิ่มเติมเช่น Add (), ช่วยให้การเพิ่ม, การลบ, การตั้งค่าองค์ประกอบและการข้ามไปข้างหน้าหรือย้อนกลับ
คลาสทั่วไปที่ใช้อินเตอร์เฟสรายการรวมถึง LinkedList, ArrayList, Vector และ Stack
คลาส LinkedList
LinkedList ใช้อินเทอร์เฟซรายการช่วยให้องค์ประกอบ NULL นอกจากนี้ LinkedList ยังให้การรับเพิ่มเติม, ลบ, แทรกวิธีการที่ส่วนหัวหรือหางของ LinkedList การดำเนินการเหล่านี้ช่วยให้ LinkedList สามารถใช้เป็นสแต็กคิวหรือคิวสองทาง
โปรดทราบว่า LinkedList ไม่มีวิธีการแบบซิงโครนัส หากหลายเธรดเข้าถึงรายการในเวลาเดียวกันคุณต้องใช้การซิงโครไนซ์การเข้าถึงด้วยตัวเอง ทางออกหนึ่งคือการสร้างรายการแบบซิงโครนัสเมื่อสร้าง:
รายการ list = collections.synchronizedList (ใหม่ LinkedList (... ));
คลาส ArrayList
ArrayList ใช้อาร์เรย์ขนาดตัวแปร ช่วยให้องค์ประกอบทั้งหมดรวมถึง Null ArrayList ไม่ได้ซิงโครไนซ์
เวลาทำงานของขนาด, isempty, get, วิธีการคงที่ อย่างไรก็ตามค่าใช้จ่ายของวิธีการเพิ่มเป็นค่าคงที่ตัดจำหน่ายและต้องใช้เวลา o (n) ในการเพิ่มองค์ประกอบ n วิธีอื่นมีเวลาทำงานเชิงเส้น
แต่ละอินสแตนซ์ ArrayList มีความจุซึ่งเป็นขนาดของอาร์เรย์ที่ใช้ในการจัดเก็บองค์ประกอบ กำลังการผลิตนี้สามารถเพิ่มขึ้นโดยอัตโนมัติเมื่อมีการเพิ่มองค์ประกอบใหม่อย่างต่อเนื่อง แต่อัลกอริทึมการเติบโตไม่ได้กำหนดไว้ เมื่อจำเป็นต้องแทรกองค์ประกอบจำนวนมากวิธีการ ensurecapacity สามารถเรียกได้ก่อนที่จะแทรกเพื่อเพิ่มความสามารถของ arraylist เพื่อปรับปรุงประสิทธิภาพการแทรก
เช่นเดียวกับ LinkedList ArrayList ก็ไม่ได้ซิงโครไนซ์
คลาสเวกเตอร์
เวกเตอร์คล้ายกับ ArrayList มาก แต่เวกเตอร์นั้นเป็นแบบซิงโครนัส แม้ว่าตัววนซ้ำที่สร้างขึ้นโดยเวกเตอร์เป็นอินเทอร์เฟซเดียวกันกับตัววนซ้ำที่สร้างขึ้นโดย arraylist เนื่องจากเวกเตอร์ถูกซิงโครไนซ์เมื่อมีการสร้างตัววนซ้ำและถูกใช้งานเธรดอื่นจะเปลี่ยนสถานะของเวกเตอร์ (ตัวอย่างเช่นการเพิ่มหรือลบองค์ประกอบบางอย่าง)
ชั้นเรียนสแต็ก
สแต็คสืบทอดมาจากเวกเตอร์โดยใช้สแต็กครั้งแรกในครั้งสุดท้าย สแต็คมีวิธีการเพิ่มเติม 5 วิธีเพื่อให้เวกเตอร์ใช้เป็นสแต็ก วิธีการกดและป๊อปขั้นพื้นฐานและวิธีการ PEEK จะได้องค์ประกอบที่ด้านบนของสแต็กวิธีการที่ว่างเปล่าจะทดสอบว่าสแต็กว่างเปล่าและวิธีการค้นหาตรวจจับตำแหน่งขององค์ประกอบในสแต็ก สแต็คเพิ่งสร้างขึ้นและเป็นสแต็คที่ว่างเปล่า
ตั้งค่าอินเตอร์เฟส
Set เป็นคอลเลกชันที่ไม่มีองค์ประกอบที่ซ้ำกันนั่นคือองค์ประกอบสององค์ประกอบ E1 และ E2 มี e1.equals (E2) = false และ Set มีองค์ประกอบ Null มากที่สุด
เห็นได้ชัดว่าตัวสร้างของ Set มีข้อ จำกัด และพารามิเตอร์การรวบรวมที่ผ่านไม่สามารถมีองค์ประกอบที่ซ้ำกันได้
โปรดทราบ: วัตถุที่เปลี่ยนแปลงได้จะต้องดำเนินการด้วยความระมัดระวัง หากองค์ประกอบที่ไม่แน่นอนในชุดเปลี่ยนสถานะของตัวเองมันจะทำให้ Object.equals (วัตถุ) = จริงเพื่อทำให้เกิดปัญหาบางอย่าง
อินเทอร์เฟซแผนที่
โปรดทราบว่าแผนที่ไม่ได้สืบทอดอินเทอร์เฟซคอลเลกชันและแผนที่ให้การแมปจากคีย์ไปยังค่า แผนที่ไม่สามารถมีคีย์เดียวกันได้และแต่ละคีย์สามารถแมปได้เพียงค่าเดียวเท่านั้น อินเทอร์เฟซแผนที่ให้มุมมองสามประเภทของคอลเลกชัน เนื้อหาของแผนที่ถือได้ว่าเป็นชุดของคอลเลกชันคีย์ชุดของคอลเลกชันค่าหรือชุดของการแมปคีย์-ค่า
คลาสแฮช
Hashtable ใช้อินเทอร์เฟซแผนที่เพื่อใช้ตารางแฮชด้วยการแมปคีย์-ค่า วัตถุที่ไม่ใช่ NULL ใด ๆ สามารถใช้เป็นคีย์หรือค่า
ใช้ใส่ (คีย์, ค่า) เพื่อเพิ่มข้อมูลใช้ GET (คีย์) เพื่อดึงข้อมูล ค่าใช้จ่ายเหนือศีรษะของการดำเนินการพื้นฐานทั้งสองนี้คงที่
Hashtable ปรับประสิทธิภาพผ่านพารามิเตอร์ความจุเริ่มต้นและพารามิเตอร์ปัจจัยโหลด โดยปกติแล้วปัจจัยโหลดเริ่มต้น 0.75 สามารถบรรลุความสมดุลเวลาและพื้นที่ได้ดีขึ้น การเพิ่มปัจจัยโหลดสามารถประหยัดพื้นที่ได้ แต่เวลาการค้นหาที่สอดคล้องกันจะเพิ่มขึ้นซึ่งจะส่งผลกระทบต่อการดำเนินงานเช่น Get and Put
ตัวอย่างง่ายๆของการใช้แฮชช์มีดังนี้: ใส่ 1, 2 และ 3 ลงในแฮชแต้มและกุญแจของพวกเขาคือ "หนึ่ง", "สอง", "สาม" ตามลำดับ:
หมายเลข Hashtable = new hashtable ();
number.put ("หนึ่ง", จำนวนเต็มใหม่ (1));
number.put ("สอง", จำนวนเต็มใหม่ (2));
number.put ("สาม", จำนวนเต็มใหม่ (3));
หากต้องการนำตัวเลขออกมาเช่น 2 ให้ใช้คีย์ที่เกี่ยวข้อง:
จำนวนเต็ม n = (จำนวนเต็ม) numbers.get ("สอง");
System.out.println ("สอง =" + n);
เนื่องจากวัตถุเป็นคีย์จะกำหนดตำแหน่งของค่าที่สอดคล้องกันโดยการคำนวณฟังก์ชั่นแฮชวัตถุใด ๆ ที่เป็นคีย์ต้องใช้วิธี HashCode และ Equals วิธีการ HashCode และ Equals สืบทอดมาจากวัตถุระดับราก หากคุณใช้คลาสที่กำหนดเองเป็นคีย์ต้องระวังให้มาก ตามคำจำกัดความของฟังก์ชั่นแฮชหากวัตถุทั้งสองเหมือนกันนั่นคือ obj1.equals (obj2) = จริง hashcode ของพวกเขาจะต้องเหมือนกัน แต่ถ้าวัตถุทั้งสองแตกต่างกัน hashcodes ของพวกเขาอาจไม่แตกต่างกัน หาก hashcodes ของวัตถุสองวัตถุที่แตกต่างกันเหมือนกันปรากฏการณ์นี้เรียกว่าความขัดแย้ง ความขัดแย้งจะเพิ่มเวลาค่าใช้จ่ายในการดำเนินงานตารางแฮช ดังนั้นลองกำหนดวิธี HashCode () เพื่อเพิ่มความเร็วในการทำงานของตารางแฮช
หากวัตถุเดียวกันมีแฮชโค้ดที่แตกต่างกันการดำเนินการบนตารางแฮชจะมีผลลัพธ์ที่ไม่คาดคิด เพื่อหลีกเลี่ยงปัญหานี้คุณเพียงแค่ต้องจำสิ่งหนึ่ง: คุณควรเขียนวิธี Equals และวิธี HashCode ในเวลาเดียวกันแทนที่จะเขียนหนึ่งในนั้น
Hashtable ถูกซิงโครไนซ์
คลาส hashmap
HashMap นั้นคล้ายคลึงกับ Hashtable ความแตกต่างคือ HashMap เป็นแบบอะซิงโครนัสและอนุญาตให้ NULL, ค่า NULL และ NULL คีย์ แต่เมื่อ HASHMAP ได้รับการพิจารณาว่าเป็นคอลเลกชัน (ค่า () สามารถคืนค่าคอลเลกชันได้) ค่าใช้จ่ายในการทำซ้ำของการวนซ้ำจะเป็นสัดส่วนกับความสามารถของ HASHMAP ดังนั้นหากประสิทธิภาพของการดำเนินการวนซ้ำมีความสำคัญมากอย่าตั้งค่าความสามารถในการเริ่มต้นของ HASHMAP ให้สูงเกินไปหรือปัจจัยโหลดต่ำเกินไป
ระดับความอ่อนแอ
WeakHashMap เป็น HASHMAP ที่ได้รับการปรับปรุงซึ่งใช้ "การอ้างอิงที่อ่อนแอ" กับคีย์ หากคีย์ไม่ได้อ้างอิงจากภายนอกอีกต่อไปคีย์สามารถรีไซเคิลได้โดย GC
สรุป
หากสแต็กคิวและการดำเนินการอื่น ๆ เกี่ยวข้องคุณควรพิจารณาใช้รายการ สำหรับองค์ประกอบที่ต้องแทรกและลบอย่างรวดเร็วคุณควรใช้ LinkedList หากจำเป็นต้องเข้าถึงองค์ประกอบอย่างรวดเร็วคุณควรใช้ ArrayList
แพ็คเกจคลาส java.util.collections
คลาส Java.util.Collections มีวิธีการที่มีประโยชน์มากมายที่สามารถทำให้การทำงานของโปรแกรมเมอร์ง่ายขึ้น แต่วิธีการเหล่านี้มักจะไม่ได้ใช้อย่างเต็มที่ Javadoc ให้คำอธิบายที่สมบูรณ์ที่สุดของคลาสคอลเลกชัน: "คลาสนี้มีคลาสแบบคงที่เฉพาะที่สามารถทำงานหรือส่งคืนคอลเลกชัน
” 1.2 วิธีการรวม
ตัววนซ้ำ, ArrayList, องค์ประกอบ, บัฟเฟอร์, แผนที่, คอลเลกชัน
Liezi:
นำเข้า java.util.arraylist; นำเข้า Java.util.Collection; นำเข้า Java.util.Collections; นำเข้า Java.util.Comparator; นำเข้า java.util.list; คอลเลกชันคลาสสาธารณะ {public collectionsSort () {} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {double array [] = {111, 111, 23, 456, 231}; รายการรายการ = new ArrayList (); รายการ li = new ArrayList (); สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); //list.add(""+Array [[ordi]); } double arr [] = {111}; สำหรับ (int j = 0; j <arr.length; j ++) {li.add (ใหม่ double (arr [j])); -2. การดำเนินการเฉพาะ
1) เรียงลำดับ (เรียงลำดับ)
ใช้วิธีการเรียงลำดับเพื่อเรียงลำดับรายการที่ระบุตามลำดับจากน้อยไปหามากตามลำดับตามธรรมชาติขององค์ประกอบ องค์ประกอบทั้งหมดในรายการจะต้องใช้อินเทอร์เฟซที่เปรียบเทียบได้ องค์ประกอบทั้งหมดในรายการนี้จะต้องเปรียบเทียบกันโดยใช้ตัวเปรียบเทียบที่ระบุ
double array [] = {112, 111, 23, 456, 231}; สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } collections.sort (รายการ); สำหรับ (int i = 0; i <array.length; i ++) {system.out.println (li.get (i)); } // ผลลัพธ์: 112,111,23,456,2312) การสับ
อัลกอริทึมการจัดเรียงแบบไฮบริดนั้นตรงกันข้ามกับการเรียงลำดับ: มันรบกวนการเปลี่ยนรูปแบบใด ๆ ที่อาจพบได้ในรายการ นั่นคือรายการจะถูกจัดเรียงใหม่ตามอินพุตของแหล่งสุ่มการจัดเรียงดังกล่าวมีความเป็นไปได้เหมือนกัน (สมมติว่าแหล่งสุ่มนั้นยุติธรรม) อัลกอริทึมนี้มีประโยชน์มากในการใช้เกมโชค ตัวอย่างเช่นสามารถใช้เพื่อผสมรายการวัตถุการ์ดที่แสดงถึงสำรับไพ่ นอกจากนี้ยังมีประโยชน์มากเมื่อสร้างกรณีทดสอบ
collections.shuffling (รายการ) double array [] = {112, 111, 23, 456, 231}; สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } collections.shuffle (รายการ); สำหรับ (int i = 0; i <array.length; i ++) {system.out.println (li.get (i)); } // ผลลัพธ์: 112,111,23,456,2313) ย้อนกลับ
ใช้วิธีการย้อนกลับเพื่อเรียงลำดับรายการที่ระบุตามลำดับจากมากไปน้อยตามลำดับตามธรรมชาติขององค์ประกอบ
collections.reverse (รายการ) อาร์เรย์สองครั้ง [] = {112, 111, 23, 456, 231}; สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } คอลเลกชัน ย้อนกลับ (รายการ); สำหรับ (int i = 0; i <array.length; i ++) {system.out.println (li.get (i)); } // ผลลัพธ์: 231,456,23,111,112 4) แทนที่องค์ประกอบทั้งหมดในรายการที่ระบุด้วยองค์ประกอบที่ระบุ string str [] = {"dd", "aa", "bb", "cc", "ee"}; สำหรับ (int j = 0; j <str.length; j ++) {li.add (สตริงใหม่ (str [j])); } คอลเลคชั่นฟิลด์ (li, "aaa"); สำหรับ (int i = 0; i <li.size (); i ++) {system.out.println ("รายการ [" + i + "] =" + li.get (i)); } // ผลลัพธ์: AAA, AAA, AAA, AAA5) คัดลอก (คัดลอก)
ใช้พารามิเตอร์สองรายการคือรายการเป้าหมายและรายการแหล่งที่มาเพื่อคัดลอกองค์ประกอบต้นทางไปยังเป้าหมายและเขียนทับเนื้อหา รายการเป้าหมายอย่างน้อยก็ตราบเท่าที่แหล่งที่มา หากนานขึ้นองค์ประกอบที่เหลือในรายการเป้าหมายจะไม่ได้รับผลกระทบ
collections.copy (list, li): พารามิเตอร์หลังคือรายการเป้าหมายรายการก่อนหน้าคือรายการต้นทาง
double array [] = {112, 111, 23, 456, 231}; รายการรายการ = new ArrayList (); รายการ li = new ArrayList (); สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } double arr [] = {1131,333}; string str [] = {"dd", "aa", "bb", "cc", "ee"}; สำหรับ (int j = 0; j <arr.length; j ++) {li.add (ใหม่ double (arr [j])); } collections.copy (list, li); สำหรับ (int i = 0; i <list.size (); i ++) {system.out.println ("รายการ [" + i + "] =" + list.get (i)); } // ผลลัพธ์: 1131,333,23,456,2316) ส่งคืนองค์ประกอบที่เล็กที่สุดในคอลเลกชัน (นาที)
ส่งคืนองค์ประกอบที่เล็กที่สุดของคอลเลกชันที่กำหนดตามลำดับที่ตัวเปรียบเทียบที่ระบุถูกสร้างขึ้น องค์ประกอบทั้งหมดในคอลเลกชันจะต้องเปรียบเทียบกันผ่านตัวเปรียบเทียบที่ระบุ
collections.min (รายการ) double array [] = {112, 111, 23, 456, 231}; รายการรายการ = new ArrayList (); สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } collections.min (รายการ); สำหรับ (int i = 0; i <list.size (); i ++) {system.out.println ("รายการ [" + i + "] =" + list.get (i)); } // ผลลัพธ์: 237) ส่งคืนองค์ประกอบที่เล็กที่สุด (สูงสุด) ในคอลเลกชัน
ส่งคืนองค์ประกอบสูงสุดของคอลเลกชันที่กำหนดตามลำดับที่ตัวเปรียบเทียบที่ระบุถูกสร้างขึ้น องค์ประกอบทั้งหมดในคอลเลกชันจะต้องเปรียบเทียบกันผ่านตัวเปรียบเทียบที่ระบุ
collections.max (รายการ) double array [] = {112, 111, 23, 456, 231}; รายการรายการ = new ArrayList (); สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } collections.max (รายการ); สำหรับ (int i = 0; i <list.size (); i ++) {system.out.println ("รายการ [" + i + "] =" + list.get (i)); } // ผลลัพธ์: 4568) LastIndexofsublist
ส่งคืนตำแหน่งเริ่มต้นของรายการเป้าหมายที่ระบุที่ปรากฏล่าสุดในรายการต้นทางที่ระบุ
int count = collections.lastindexofsublist (รายการ, li); double array [] = {112, 111, 23, 456, 231}; รายการรายการ = new ArrayList (); รายการ li = new ArrayList (); สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } double arr [] = {111}; string str [] = {"dd", "aa", "bb", "cc", "ee"}; สำหรับ (int j = 0; j <arr.length; j ++) {li.add (ใหม่ double (arr [j])); } สถานที่ int = คอลเลกชัน LastIndexofsublist (รายการ, Li); System.out.println ("==="+ ตำแหน่ง); // ผลลัพธ์ 39) INDEXOFSUBLIST
ส่งคืนตำแหน่งเริ่มต้นของครั้งแรกที่รายการเป้าหมายที่ระบุจะปรากฏในรายการต้นทางที่ระบุ
int count = collections.indexofsublist (list, li); double array [] = {112, 111, 23, 456, 231}; รายการรายการ = new ArrayList (); รายการ li = new ArrayList (); สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } double arr [] = {111}; string str [] = {"dd", "aa", "bb", "cc", "ee"}; สำหรับ (int j = 0; j <arr.length; j ++) {li.add (ใหม่ double (arr [j])); } สถานที่ int = collections.indexofsublist (list, li); System.out.println ("==="+ ตำแหน่ง); // ผลลัพธ์ 110) หมุน
การเคลื่อนย้ายองค์ประกอบในรายการที่ระบุตามระยะทางที่ระบุ
collections.rotate (รายการ, -1);
ถ้ามันเป็นจำนวนลบมันจะเคลื่อนที่ในเชิงบวกและถ้ามันเคลื่อนที่ในเชิงบวกมันจะเคลื่อนที่ในเชิงบวก
double array [] = {112, 111, 23, 456, 231}; รายการรายการ = new ArrayList (); สำหรับ (int i = 0; i <array.length; i ++) {list.add (ใหม่สองเท่า (อาร์เรย์ [i])); } collections.rotate (รายการ, -1); สำหรับ (int i = 0; i <list.size (); i ++) {system.out.println ("รายการ [" + i + "] =" + list.get (i)); } // ผลลัพธ์: 111,23,456,231,112บทความข้างต้นกล่าวถึงการรวบรวมคลาสการใช้งานสั้น ๆ และแผนที่ของโครงสร้างข้อมูลที่ใช้กันทั่วไปใน Java นี่คือเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่าคุณจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น