รายการ Java

Java Collection Framework มีอินเตอร์เฟสและคลาสที่มีประโยชน์มากซึ่งนำไปใช้สำหรับการทำงานกับโครงสร้างข้อมูล อาจกล่าวได้ว่านี่คือหนึ่งในเฟรมเวิร์กที่สำคัญที่สุดของ JDK อินเทอร์เฟซรายการเป็นที่นิยมมาก เนื่องจากไม่มีรายการทุกประเภทในการเขียนโปรแกรมจึงขาดไม่ได้ ในบทความนี้ เราจะกล่าวถึงอินเทอร์เฟซนี้ วิธี Java List และการใช้งาน

อินเทอร์เฟซรายการ Java

สิ่งที่สำคัญที่สุดเกี่ยวกับรายการคือเป็นการรวบรวมคำสั่ง คุณยังสามารถเรียกมันว่าลำดับ ใน Java รายการจะเป็นเนื้อเดียวกัน กล่าวคือ องค์ประกอบของรายการเป็นประเภทข้อมูลเดียวกัน อินเตอร์เฟส Java List สืบทอดมาจาก Collection ซึ่งจะสืบทอดการดำเนินการทั้งหมด นอกเหนือจากนั้น การดำเนินการต่อไปนี้ยังเป็นไปได้ในรายการ:

• การเข้าถึงตำแหน่ง แต่ละองค์ประกอบมีดัชนีและสามารถจัดการได้ตามตำแหน่ง ในรายการ นั่นคือ คุณสามารถเพิ่ม ไม่รวม และแก้ไของค์ประกอบต่างๆ
• ค้นหา. คุณสามารถค้นหาองค์ประกอบในรายการตามเนื้อหาและส่งคืนดัชนี
• การทำซ้ำ ลักษณะลำดับของรายการอนุญาตให้ใช้วิธีการวนซ้ำ (listIterator)
• มุมมองระยะไกล เมธอดรายการย่อยดำเนินการช่วงตามอำเภอใจในรายการ

วิธีการรายการ Java

การดำเนินการข้างต้นแสดงในวิธีการของอินเตอร์เฟส Java List นี่คือบางส่วนของพวกเขา:

การใช้งานรายการ

เนื่องจากรายการเป็นส่วนต่อประสาน โปรแกรมจำเป็นต้องสร้างการใช้งานที่เป็นรูปธรรมของมัน คุณสามารถเลือกระหว่างการใช้งานรายการต่อไปนี้ใน Java Collections API:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

การนำอินเทอร์เฟซรายการที่เรียกว่า ArrayList มาใช้ที่ได้รับความนิยมมากที่สุด น้อยกว่ามาก แต่คุณยังสามารถเห็นการใช้ LinkedList ในงานจริงได้ แต่ Vector และ Stack นั้นล้าสมัยทางศีลธรรมไปนานแล้ว ดังนั้นคุณมักจะพบพวกเขาในโครงการที่มีรหัสดั้งเดิมโบราณเท่านั้น

รายการประกาศส่วนต่อประสาน

คุณสามารถประกาศ List ในโปรแกรม Java ได้ด้วยวิธีใดวิธีหนึ่งต่อไปนี้:

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

ทางที่ดีควรประกาศรายชื่อใหม่ผ่านทางอินเทอร์เฟซ ในทำนองเดียวกัน คุณสามารถประกาศการใช้งานรายการอื่นๆ ได้ วิธีที่สั้นที่สุด:

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

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

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

ตอนนี้สามารถเพิ่มได้เฉพาะสตริงในสแต็คของเรา จำนวนเต็มเป็นLinkedInListลอยไปที่myVectorและmyListเป็นรายการอักขระ

ArrayList ทำงานอย่างไร

หากคุณคุ้นเคยกับอาร์เรย์ปกติอยู่แล้ว คุณก็คุ้นเคยกับ ArrayList อยู่บ้าง ในความเป็นจริง ArrayList เป็นอาร์เรย์แบบไดนามิก และภายในนั้นเป็นอาร์เรย์ธรรมดา อาร์เรย์นี้ทำหน้าที่เป็นที่เก็บข้อมูล ArrayList เก็บเฉพาะประเภทการอ้างอิง ออบเจกต์ใดๆ รวมถึงคลาสของบุคคลที่สาม สตริง เอาต์พุตสตรีม และคอลเล็กชันอื่นๆ คลาส Wrapper ใช้เพื่อจัดเก็บประเภทข้อมูลดั้งเดิมใน ArrayList เมื่อสร้างรายการ เราสามารถกำหนดขนาดของรายการได้ทันที แต่โดยส่วนใหญ่เราจะทำไม่ได้ ตามค่าเริ่มต้น ArrayList size = 10 การเพิ่มองค์ประกอบใหม่ไปยัง ArrayList มีลักษณะอย่างไร ก่อนอื่น การตรวจสอบจะเริ่มขึ้นเพื่อดูว่ามีพื้นที่เพียงพอในอาร์เรย์ภายในหรือไม่ และองค์ประกอบอื่นจะพอดีหรือไม่ หากมีช่องว่าง องค์ประกอบใหม่จะถูกเพิ่มที่ส่วนท้ายของรายการ ซึ่งก็คือเซลล์ที่อยู่ถัดจากองค์ประกอบสุดท้าย ดัชนีจะเป็น arraylist.size() หากเราเพิ่งสร้างรายการของเราและรายการว่างเปล่า นั่นหมายความว่า arrayList.size() = 0 ดังนั้น องค์ประกอบใหม่จะถูกเพิ่มลงในเซลล์ที่มีดัชนี 0 หากปรากฎว่ามีพื้นที่ไม่เพียงพอ รายการใหม่ อาร์เรย์ถูกสร้างขึ้นภายใน ArrayList ด้วยขนาด (ขนาดของ OldArray * 1.5) + 1 ด้วยหลักการเดียวกัน การแทรกจะเกิดขึ้นตรงกลางรายการ แต่ในขณะเดียวกัน องค์ประกอบทั้งหมดที่ตามหลังองค์ประกอบที่แทรกเข้าไปคือ เลื่อนไปทางขวา ดังนั้น หากเรามี 5 องค์ประกอบในอาร์เรย์ และเราจำเป็นต้องแทรกองค์ประกอบลงในเซลล์หมายเลข 2 (นั่นคือเซลล์ที่สาม) จากนั้นองค์ประกอบอาร์เรย์ 0 และ 1 จะยังคงอยู่ องค์ประกอบใหม่จะปรากฏในเซลล์ 2 และ บรรพบุรุษของมันจะไปที่เซลล์ที่สามเป็นต้น องค์ประกอบใหม่จะถูกเพิ่มลงในเซลล์ที่มีดัชนี 0 หากปรากฎว่ามีพื้นที่ไม่เพียงพอจะมีการสร้างอาร์เรย์ใหม่ภายใน ArrayList ด้วยขนาด (ขนาดของ OldArray * 1.5) + 1 โดยเช่นเดียวกัน หลักการ การแทรกจะเกิดขึ้นตรงกลางรายการ แต่ในขณะเดียวกัน องค์ประกอบทั้งหมดที่ตามหลังองค์ประกอบที่แทรกจะถูกเลื่อนไปทางขวา ดังนั้น หากเรามี 5 องค์ประกอบในอาร์เรย์ และเราจำเป็นต้องแทรกองค์ประกอบลงในเซลล์หมายเลข 2 (นั่นคือเซลล์ที่สาม) จากนั้นองค์ประกอบอาร์เรย์ 0 และ 1 จะยังคงอยู่ องค์ประกอบใหม่จะปรากฏในเซลล์ 2 และ บรรพบุรุษของมันจะไปที่เซลล์ที่สามเป็นต้น องค์ประกอบใหม่จะถูกเพิ่มลงในเซลล์ที่มีดัชนี 0 หากปรากฎว่ามีพื้นที่ไม่เพียงพอจะมีการสร้างอาร์เรย์ใหม่ภายใน ArrayList ด้วยขนาด (ขนาดของ OldArray * 1.5) + 1 โดยเช่นเดียวกัน หลักการ การแทรกจะเกิดขึ้นตรงกลางรายการ แต่ในขณะเดียวกัน องค์ประกอบทั้งหมดที่ตามหลังองค์ประกอบที่แทรกจะถูกเลื่อนไปทางขวา ดังนั้น หากเรามี 5 องค์ประกอบในอาร์เรย์ และเราจำเป็นต้องแทรกองค์ประกอบลงในเซลล์หมายเลข 2 (นั่นคือเซลล์ที่สาม) จากนั้นองค์ประกอบอาร์เรย์ 0 และ 1 จะยังคงอยู่ องค์ประกอบใหม่จะปรากฏในเซลล์ 2 และ บรรพบุรุษของมันจะไปที่เซลล์ที่สามเป็นต้น การแทรกเกิดขึ้นที่กลางรายการ แต่ในขณะเดียวกัน องค์ประกอบทั้งหมดที่ตามหลังองค์ประกอบที่แทรกจะถูกเลื่อนไปทางขวา ดังนั้น หากเรามี 5 องค์ประกอบในอาร์เรย์ และเราจำเป็นต้องแทรกองค์ประกอบลงในเซลล์หมายเลข 2 (นั่นคือเซลล์ที่สาม) จากนั้นองค์ประกอบอาร์เรย์ 0 และ 1 จะยังคงอยู่ องค์ประกอบใหม่จะปรากฏในเซลล์ 2 และ บรรพบุรุษของมันจะไปที่เซลล์ที่สามเป็นต้น การแทรกเกิดขึ้นที่กลางรายการ แต่ในขณะเดียวกัน องค์ประกอบทั้งหมดที่ตามหลังองค์ประกอบที่แทรกจะถูกเลื่อนไปทางขวา ดังนั้น หากเรามี 5 องค์ประกอบในอาร์เรย์ และเราจำเป็นต้องแทรกองค์ประกอบลงในเซลล์หมายเลข 2 (นั่นคือเซลล์ที่สาม) จากนั้นองค์ประกอบอาร์เรย์ 0 และ 1 จะยังคงอยู่ องค์ประกอบใหม่จะปรากฏในเซลล์ 2 และ บรรพบุรุษของมันจะไปที่เซลล์ที่สามเป็นต้น

ตัวอย่างรายการ Java (การรับรู้ Arraylist)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

นี่คือผลลัพธ์ของโปรแกรมนี้:

วิธีการทำงานของ LinkedList

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

ตัวอย่างโค้ด

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

ผลลัพธ์อยู่ที่นี่:

ตัวอย่างรหัสเวกเตอร์

เวกเตอร์ยังเป็นการสร้างอาร์เรย์แบบไดนามิกและคล้ายกับ ArrayList มาก แต่ซิงโครไนซ์และมีวิธีการดั้งเดิมบางอย่างที่เฟรมเวิร์กการรวบรวมไม่มี นี่คือตัวอย่างง่ายๆของการใช้คลาสนี้

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

ผลลัพธ์คือ:

ตัวอย่างโค้ดคลาส Java Stack

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

สแต็กไม่ได้มีแค่ เมธอด add()และremove() เท่านั้น แต่ยังรวมถึง push และ pop ด้วย ซึ่งเป็นแบบคลาสสิกสำหรับโครงสร้างข้อมูลดังกล่าว สแต็คปฏิบัติตามกฎ "เข้าก่อน ออกก่อน" — นี่เป็นการต่อต้านการเข้าคิว ดังนั้น การดำเนินการป๊อปจะแสดงองค์ประกอบที่วางล่าสุดบนสแต็ก นี่คือผลลัพธ์ของตัวอย่างของเรา: