คอลเลกชันใน Java

คอลเลกชันใน Java คืออะไร?

คอลเลกชันใน Java จะแสดงเป็นคอนเทนเนอร์ที่จัดกลุ่มองค์ประกอบทั้งหมดไว้ในหน่วยเดียว ตัวอย่างเช่นโฟลเดอร์เมล (กลุ่มอีเมล) สมุดโทรศัพท์ (การจับคู่ชื่อกับหมายเลขโทรศัพท์)

กรอบงานคืออะไร?

เฟรมเวิร์กเป็นรากฐานหรือโครงร่างพื้นฐานที่คุณเริ่มทำงานโดยใช้คลาสและอินเทอร์เฟซต่างๆ ที่มีให้ ตัวอย่างเช่น Laravel เป็นหนึ่งในเฟรมเวิร์ก PHP ที่มีชื่อเสียงที่สุดซึ่งมีโครงสร้างพื้นฐานสำหรับแอปพลิเคชันของคุณ

Collections Framework ใน Java คืออะไร?

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

import java.util.*;

หากคุณต้องการนำเข้าคอลเลกชันเฉพาะ ให้ใช้ชื่อแพ็คเกจให้ตรงกันทุกประการ เช่น:

import java.util.LinkedList;

ประโยชน์ของ Collections Framework ใน Java

มันมีประโยชน์ดังต่อไปนี้

1. ดำเนินการแล้ว (ประหยัดเวลา)
2. ประสิทธิภาพ ประสิทธิภาพ (ความเร็วและคุณภาพ)
3. ลดความพยายามในการเรียนรู้และใช้ API ใหม่

ลำดับชั้นของกรอบงานคอลเลกชันคืออะไร

ตอนนี้เรามาดูลำดับชั้นของคอลเลกชันกันก่อน แต่ก่อนอื่น เราจำเป็นต้องรู้องค์ประกอบที่สำคัญของกรอบงานนี้

1. อินเทอร์เฟซ
2. คลาส (การนำไปใช้งาน)
3. อัลกอริทึม

ลำดับชั้นของกรอบการรวบรวม

เพื่อความเข้าใจของคุณ:

1. คอลเลกชัน ชุด คิว และรายการทั้งหมดเป็นอินเทอร์เฟซ ชุด คิว และรายการถูกขยาย โดยอินเทอร์เฟซของคอลเลกชัน
2. PriorityQueue, HashSet, LinkedList และ Stack ทั้งหมดเป็นคลาสหรือการใช้งานอินเทอร์เฟซเหล่านี้
3. ไม่จำเป็นว่าคลาสจะต้องใช้ เพียงอินเทอร์เฟซเดียว LinkedList ยังใช้อินเทอร์เฟซ Deque อีกด้วย

ประเภทของคอลเลกชัน

เฟรมเวิร์กคอลเลกชัน Java มีคอลเลกชันหลายประเภทเพื่อลดความพยายามของเรา นี่คือรายการคอลเลกชันบางส่วน:

1. คลาส ArrayList
2. คลาส LinkedList
3. รายการอินเทอร์เฟซ
4. ตั้งค่าอินเทอร์เฟซ
5. อินเทอร์เฟซคิว
6. อินเตอร์เฟซแผนที่
7. คลาส PriorityQueue
8. คลาส HashMap
9. อินเทอร์เฟซที่เปรียบเทียบได้
10. คลาส LinkedHashMap
11. คลาส TreeMap
12. แฮชเทเบิล

อินเทอร์เฟซของคอลเลกชัน

ที่นี่เราจะพูดถึงอินเทอร์เฟซการรวบรวมทั่วไปบางส่วนและวิธีการบางอย่างที่คลาสนำมาใช้

อินเตอร์เฟซการรวบรวม

นี่เป็นรากฐานพื้นฐานสำหรับเฟรมเวิร์ก Collections เนื่องจากมีวิธีการที่จำเป็นทั้งหมดสำหรับการนำไปปฏิบัติ แผนที่เป็นโครงสร้างข้อมูลเดียวที่ไม่ได้ใช้ แต่ส่วนที่เหลือทั้งหมดใช้วิธีการของมัน อินเทอร์เฟซนี้มีวิธีการทราบขนาดของคอลเลกชัน และดูว่ามีวัตถุอยู่ในคอลเลกชันหรือไม่ การเพิ่มหรือลบวัตถุออกจากคอลเลกชัน

อินเทอร์เฟซที่ทำซ้ำได้

เป็นอินเทอร์เฟซรูทสำหรับเฟรมเวิร์กคอลเลกชันเนื่องจากขยายโดยอินเทอร์เฟซคอลเลกชันซึ่งใช้งานโดยคลาสทั้งหมด มันจะส่งคืนตัววนซ้ำสำหรับคอลเลกชันเฉพาะเพื่อวนซ้ำ

อินเทอร์เฟซคิว

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

ตั้งค่าอินเทอร์เฟซ

Set ใช้เพื่อเก็บองค์ประกอบที่เป็นเอกลักษณ์ไว้ มันไม่เคยมีองค์ประกอบและแบบจำลองที่ซ้ำกันซึ่งเป็นนามธรรมของชุดทางคณิตศาสตร์เพื่อแสดงชุดต่างๆ เช่น กระบวนการที่ทำงานบนเครื่อง

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

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

อินเตอร์เฟซดีเคว

Deque ย่อมาจาก double-ended Queue ซึ่งหมายความว่าเราสามารถดำเนินการได้ทั้งสองด้าน เราสามารถแทรกและลบองค์ประกอบออกจากปลายทั้งสองข้างได้ อินเทอร์เฟซ Deque ขยายอินเทอร์เฟซคิว ArrayDeque และ LinkedList ต่างก็ใช้อินเทอร์เฟซ Deque โดยจัดเตรียมวิธีการแทรก การลบ และตรวจสอบอินสแตนซ์จากปลายทั้งสองด้าน

อินเตอร์เฟซแผนที่

อินเทอร์เฟซแผนที่ยังเป็นส่วนหนึ่งของกรอบงานคอลเลกชัน แต่ไม่ได้ขยายอินเทอร์เฟซคอลเลกชัน มันถูกใช้เพื่อจัดเก็บคู่คีย์-ค่า การใช้งานหลักคือ HashMap, TreeMap และ LinkesHashMap ซึ่งมีความคล้ายคลึงในบางแง่มุมกับ HashSet, TreeSet และ LinkedHashSet ประกอบด้วยคีย์ที่ไม่ซ้ำเสมอ แต่ค่าสามารถทำซ้ำได้ ซึ่งจะมีประโยชน์เมื่อคุณต้องการเพิ่ม ลบ หรือค้นหารายการตามคีย์ มันให้วิธีการพื้นฐานแก่เรา เช่นใส่ , รับ , ลบ , ขนาด , ว่างเปล่าและอื่นๆ

วิธีการทั่วไปของอินเทอร์เฟซเหล่านี้

ตอนนี้เราจะมาดูวิธีการทั่วไปบางประการที่มีไว้สำหรับการใช้งานคลาสต่างๆ ในเฟรมเวิร์กนี้ ยกเว้นอินเทอร์เฟซแผนที่

คลาสสะสม

ดังที่เราทราบเฟรมเวิร์กมีอินเทอร์เฟซที่แตกต่างกันซึ่งมีหลายคลาสที่อยู่ภายใน ตอนนี้เรามาดูคลาสที่ใช้กันทั่วไปบ้าง

รายการที่เชื่อมโยง

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

ตัวอย่าง

import java.util.*;

public class LinkedListExample {
    public static void main(String[] args) {
        Queue<String> customerQueue = new LinkedList<String>();
        //Adding customers to the Queue as they arrived
        customerQueue.add("John");
        customerQueue.add("Angelina");
        customerQueue.add("Brooke");
        customerQueue.add("Maxwell");

        System.out.println("Customers in Queue:"+customerQueue);
        //element() => returns head of the queue
        //we will see our first customer and serve him
        System.out.println("Head of the queue i.e first customer: "+customerQueue.element());
        //remove () method =>removes first element(customer) from the queue i.e the customer is served so remove him to see next
        System.out.println("Element removed from the queue: "+customerQueue.remove());
        //poll () => removes and returns the head
        System.out.println("Poll():Returned Head of the queue: "+customerQueue.poll());
        //print the remaining customers in the Queue
        System.out.println("Final Queue:"+customerQueue);
    }
}

เอาท์พุต

ArrayList

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

ตัวอย่าง

public class ArrayListExample {
	public static void main(String args[]) {

		// Creating the ArrayList
		ArrayList<String> books = new ArrayList<String>();

		// Adding a book to the list
		books.add("Absalom, Absalom!");
		// Adding a book in array list
		books.add("A Time to Kill");
		// Adding a book to the list
		books.add("The House of Mirth");
		// Adding a book to the list
		books.add("East of Eden");
		// Traversing the list through Iterator
		Iterator<String> itr = books.iterator();
		while (itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

เอาท์พุต

แฮชเซ็ต

ใช้อินเทอร์เฟซ Set และไม่มีค่าที่ซ้ำกัน ใช้ตารางแฮชเพื่อจัดเก็บค่า นอกจากนี้ยังอนุญาตให้มีค่าว่าง มันไม่เคยรักษาลำดับการแทรก แต่ให้ประสิทธิภาพเวลาคงที่สำหรับการเพิ่ม , ลบ , ขนาดและมีวิธีการ เหมาะที่สุดสำหรับการดำเนินการค้นหาและไม่มีการซิงโครไนซ์

ตัวอย่าง

import java.util.*;
class HashSetExample{
    public static void main(String args[]){
        //creating HashSet and adding elements to it
        HashSet<Integer> hashSet=new HashSet();
        hashSet.add(1);
        hashSet.add(5);
        hashSet.add(4);
        hashSet.add(3);
        hashSet.add(2);
        //getting an iterator for the collection
        Iterator<Integer> i=hashSet.iterator();
        //iterating over the value
        while(i.hasNext())  {
            System.out.println(i.next());
        }
    }
}

เอาท์พุต

อย่างที่คุณเห็นว่ามันไม่ได้รักษาลำดับการแทรก

อาร์เรย์Deque

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

ตัวอย่าง

import java.util.*;
public class ArrayDequeExample {
   public static void main(String[] args) {
       //creating Deque and adding elements
       Deque<String> deque = new ArrayDeque<String>();
       //adding an element
       deque.add("One");
       //adding an element at the start
       deque.addFirst("Two");
       //adding an element at the end
       deque.addLast("Three");
       //traversing elements of the collection
       for (String str : deque) {
            System.out.println(str);
       }
   }
}

เอาท์พุต

แฮชแมป

เป็นการนำอินเทอร์เฟซแผนที่ไปใช้ซึ่งสนับสนุนโดยตารางแฮช มันเก็บคู่คีย์-ค่า ไม่อนุญาตให้มีค่าว่าง มันไม่ได้รับการซิงโครไนซ์ มันไม่รับประกันลำดับการแทรก มันให้ประสิทธิภาพเวลาคงที่สำหรับวิธีการเช่นgetและput ประสิทธิภาพการทำงานขึ้นอยู่กับปัจจัยสองประการ — ความจุเริ่มต้นและปัจจัยโหลด ความจุคือจำนวนบัคเก็ตในตารางแฮช ดังนั้นความจุเริ่มต้นคือจำนวนบัคเก็ตที่จัดสรร ณ เวลาที่สร้าง Load Factor คือการวัดจำนวนตารางแฮชที่สามารถเติมได้ก่อนที่ความจุจะเพิ่มขึ้น วิธีการปรับปรุงใหม่ใช้เพื่อเพิ่มความจุและเพิ่มจำนวนที่เก็บข้อมูลเป็นสองเท่าเป็นหลัก

ตัวอย่าง

import java.util.*;
public class HashMapExample{
    public static void main(String args[]){
        //creating a HashMap
        HashMap<Integer,String> map=new HashMap<Integer,String>();
        //putting elements into the map
        map.put(1,"England");
        map.put(2,"USA");
        map.put(3,"China");

        //get element at index 2
        System.out.println("Value at index 2 is: "+map.get(2));
        System.out.println("iterating map");
        //iterating the map
        for(Map.Entry m : map.entrySet()){
            System.out.println(m.getKey()+" "+m.getValue());
        }
    }
}

เอาท์พุต

อัลกอริทึม

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

1. การเรียงลำดับ
2. กำลังค้นหา
3. สับ
4. การจัดการข้อมูลประจำ
5. องค์ประกอบ
6. การค้นหาคุณค่าสูงสุด

เพื่อความเข้าใจที่ดีขึ้น เราจะหารือเกี่ยวกับอัลกอริทึมการเรียงลำดับ

การเรียงลำดับ

อัลกอริธึมการเรียงลำดับจะจัดลำดับรายการใหม่ตามความสัมพันธ์ในการจัดลำดับ ความสัมพันธ์มีให้สองรูปแบบ

1. การสั่งซื้อตามธรรมชาติ
2. การสั่งซื้อเปรียบเทียบ

การสั่งซื้อตามธรรมชาติ

ในการเรียงลำดับตามธรรมชาติ รายการจะถูกจัดเรียงตามองค์ประกอบ

การสั่งซื้อเปรียบเทียบ

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

ตัวอย่าง

import java.util.*;
public class SortingExample{
    public static void main(String args[]){
        //Creating arraylist
        ArrayList<String> books=new ArrayList<String>();
        //Adding a book to the arraylist
        books.add("A Time to Kill");
        //Adding a book to the arraylist
        books.add("Absalom, Absalom!");
        //Adding a book to the arraylist
        books.add("The House of Mirth");
        //Adding a book to the arraylist
        books.add("East of Eden");
        //Traversing list through Iterator before sorting
        Iterator itrBeforeSort=books.iterator();
        while(itrBeforeSort.hasNext()){
            System.out.println(itrBeforeSort.next());
        }
        //sorting the books
        Collections.sort(books);
        System.out.println("After sorting the books");
        //Traversing list through Iterator after sorting
        Iterator itr=books.iterator();
        while(itr.hasNext()){
            System.out.println(itr.next());
        }
    }
}

เอาท์พุต

บทสรุป

เราหวังว่าตอนนี้คุณคงเข้าใจแล้วว่าเฟรมเวิร์กคอลเลกชัน Java คืออะไร อินเทอร์เฟซและคลาสของมันคืออะไร และจะใช้งานคลาสต่างๆ ได้อย่างไร คุณสามารถใช้เฟรมเวิร์กนี้เพื่อลดความพยายามของคุณใน Java ได้เสมอ คุณสามารถฝึกฝนและกลับมาที่นี่ได้ทุกเมื่อที่คุณต้องการความช่วยเหลือเพิ่มเติม มีความสุขในการเรียนรู้!