การอภิปรายสั้น ๆ เกี่ยวกับการรวบรวมคลาสการใช้งานและแผนที่ของโครงสร้างข้อมูลที่ใช้กันทั่วไปใน Java

ตารางเชิงเส้นรายการที่เชื่อมโยงและตารางแฮชเป็นโครงสร้างข้อมูลที่ใช้กันทั่วไป เมื่อพัฒนา 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,231

2) การสับ

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

 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,231

3) ย้อนกลับ

ใช้วิธีการย้อนกลับเพื่อเรียงลำดับรายการที่ระบุตามลำดับจากมากไปน้อยตามลำดับตามธรรมชาติขององค์ประกอบ

 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, AAA

5) คัดลอก (คัดลอก)

ใช้พารามิเตอร์สองรายการคือรายการเป้าหมายและรายการแหล่งที่มาเพื่อคัดลอกองค์ประกอบต้นทางไปยังเป้าหมายและเขียนทับเนื้อหา รายการเป้าหมายอย่างน้อยก็ตราบเท่าที่แหล่งที่มา หากนานขึ้นองค์ประกอบที่เหลือในรายการเป้าหมายจะไม่ได้รับผลกระทบ

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,231

6) ส่งคืนองค์ประกอบที่เล็กที่สุดในคอลเลกชัน (นาที)

ส่งคืนองค์ประกอบที่เล็กที่สุดของคอลเลกชันที่กำหนดตามลำดับที่ตัวเปรียบเทียบที่ระบุถูกสร้างขึ้น องค์ประกอบทั้งหมดในคอลเลกชันจะต้องเปรียบเทียบกันผ่านตัวเปรียบเทียบที่ระบุ

 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)); } // ผลลัพธ์: 23

7) ส่งคืนองค์ประกอบที่เล็กที่สุด (สูงสุด) ในคอลเลกชัน

ส่งคืนองค์ประกอบสูงสุดของคอลเลกชันที่กำหนดตามลำดับที่ตัวเปรียบเทียบที่ระบุถูกสร้างขึ้น องค์ประกอบทั้งหมดในคอลเลกชันจะต้องเปรียบเทียบกันผ่านตัวเปรียบเทียบที่ระบุ

 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)); } // ผลลัพธ์: 456

8) 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 ("==="+ ตำแหน่ง); // ผลลัพธ์ 3

9) 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 ("==="+ ตำแหน่ง); // ผลลัพธ์ 1

10) หมุน

การเคลื่อนย้ายองค์ประกอบในรายการที่ระบุตามระยะทางที่ระบุ
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 มากขึ้น