אוספים בג'אווה

מהו אוסף בג'אווה?

אוסף ב-java מיוצג כמיכל המקבץ את כל האלמנטים ליחידה אחת. לדוגמה , תיקיית דואר (קבוצת מיילים), ספריית טלפונים (מיפוי שמות למספרי טלפון).

מהי מסגרת?

מסגרת היא בסיס או פריסה בסיסית שעליה אתה מתחיל לעבוד באמצעות המחלקות והממשקים השונים שסופקו. לדוגמה , Laravel היא אחת ממסגרות ה-PHP המפורסמות ביותר המספקות שלד בסיסי ליישום שלך.

מהי מסגרת האוספים ב-Java?

כל האובייקטים מקובצים לאובייקט בודד יחד עם ארכיטקטורה המייצגת ומספקת שיטות שונות למניפולציה של אוספים. אז מסגרת Collections ב-Java מספקת מבני נתונים שונים שכבר מיושמים לאחסון נתונים ושיטות, כדי לתמרן אותם עם תכונות כמו מיון, חיפוש, מחיקה והוספה . לדוגמה , אתה רוצה ליישם מערכת עבור חברה אקראית כלשהי כדי לשפר את השירות ללקוחותיה, על בסיס כל הקודם זוכה. זה ידוע גם בתור יישום FIFO (ראשון ביציאה ראשון). כעת עלינו ליישם את מבנה הנתונים הזה ולאחר מכן להשתמש בו כדי להשיג את המטרה שלנו. המסגרת של Collections מספקת לנו ממשק Queue שאנו צריכים רק לייבא במקום ליישם, ואז להשתמש בו, וסיימנו. יישום : ניתן לייבא את כל האוספים באמצעות השורה הבאה:

import java.util.*;

אם ברצונך לייבא אוסף מסוים, השתמש בשם החבילה המדויק, כגון:

import java.util.LinkedList;

היתרונות של Collections Framework ב-Java

יש לו את היתרונות הבאים.

1. כבר מיושם (חוסך זמן).
2. יעילות ביצועים (מהירות ואיכות).
3. מפחית את המאמץ ללמוד ולהשתמש בממשקי API חדשים.

מהי ההיררכיה של מסגרת האיסוף?

עכשיו בואו נראה את היררכיית האוספים אבל ראשית, עלינו להכיר את המרכיבים החיוניים של המסגרת הזו.

1. ממשקים
2. שיעורים (יישום)
3. אלגוריתמים

היררכיה של מסגרת אוסף

להבנתך:

1. Collection, Set, Queue ו- List כולם הם ממשקים. הסט, התור והרשימה מורחבים על ידי ממשק האוסף.
2. PriorityQueue, HashSet, LinkedList ו-Stack כולם מחלקות או יישום של ממשקים אלה.
3. זה לא חובה שמחלקה מיישמת ממשק אחד בלבד. LinkedList גם מיישמת את ממשק Deque, למשל.

סוגי אוספים

במסגרת Java collections יש הרבה סוגי אוספים כדי לצמצם את המאמצים שלנו. להלן רשימה של חלק מהאוספים:

1. מחלקה ArrayList
2. כיתת LinkedList
3. ממשק רשימה
4. הגדר ממשק
5. ממשק תור
6. ממשק מפה
7. Class PriorityQueue
8. כיתת HashMap
9. ממשק בר השוואה
10. כיתת LinkedHashMap
11. שיעור TreeMap
12. טבלת גיבוב

ממשקי אוסף

כאן נדון בכמה ממשקי איסוף נפוצים ולאחר מכן בכמה שיטות המיושמות על ידי המחלקות.

ממשק אוסף

זהו בסיס בסיסי למסגרת האוספים שכן היא מספקת את כל השיטות הדרושות ליישום. המפה היא מבנה הנתונים היחיד שלא מיישם אותו, אבל הנותרים כולם מיישמים את השיטות שלו. לממשק זה יש שיטות לדעת את גודל האוסף, והאם קיים אובייקט באוסף, הוספה או הסרה של אובייקטים מהאוסף.

ממשק שניתן לחזור עליו

זהו ממשק השורש למסגרת Collections כפי שהוא מורחב על ידי ממשק Collection אשר מיושם על ידי כל המחלקות. הוא מחזיר איטרטור עבור האוסף הספציפי שיחזור עליו.

ממשק תור

התור משמש כדי להחזיק את האלמנטים אך לא ניתן לעבד אותם. תוך יישום פעולות האיסוף הבסיסיות, הוא מספק גם שיטות הכנסה וחילוץ נוספות.

הגדר ממשק

סט משמש להחזקת אלמנטים ייחודיים בו. הוא אף פעם לא מכיל אלמנטים כפולים ומדגמן את הפשטת הקבוצות המתמטיות כדי לייצג את הקבוצות כגון תהליכים הפועלים במכונה.

ממשק רשימה

רשימה היא אוסף מסודר הנקרא לפעמים רצף שיכול להכיל בתוכו אלמנטים כפולים. הוא מספק שליטה למשתמש על עדכון או הסרה של אלמנט מסוים, הוספת אלמנט בנקודה מסוימת על ידי שימוש בערך האינדקס השלם שלו. LinkedList ו-ArrayList הם מחלקות יישום של ממשק List.

ממשק Deque

Deque מייצג את התור הכפול מה שאומר שאנחנו יכולים לבצע פעולות בשני הקצוות. אנו יכולים להכניס ולהסיר אלמנטים משני הקצוות. ממשק Deque מרחיב את ממשק התור. ArrayDeque ו-LinkedList מיישמים שניהם את ממשק Deque. הוא מספק שיטות להכנסה, מחיקה ובחינה של המופע משני הקצוות.

ממשק מפה

ממשק המפה הוא גם חלק ממסגרת האוספים אך הוא אינו מרחיב את ממשק האוסף. הוא משמש לאחסון צמדי מפתח-ערך. המימושים העיקריים שלו הם HashMap, TreeMap ו-LinkesHashMap הדומים בהיבטים מסוימים ל-HashSet, TreeSet ו-LinkedHashSet. הוא תמיד מכיל מפתחות ייחודיים אך ניתן לשכפל את הערכים. זה שימושי כאשר אתה צריך להוסיף, למחוק או לחפש פריט על סמך מפתח. הוא מספק לנו שיטות בסיסיות כמו לשים , לקבל , להסיר , גודל , ריק וכו'.

שיטות נפוצות של ממשקים אלה

כעת נסתכל על כמה שיטות נפוצות הניתנות ליישום של מחלקות שונות במסגרת זו למעט ממשק המפה.

שיעורי איסוף

כפי שאנו יודעים למסגרת יש ממשקים שונים אשר מיושמים על ידי מחלקות רבות בתוכה. עכשיו בואו נסתכל על כמה שיעורים נפוצים.

רשימה מקושרת

זהו מבנה הנתונים הנפוץ ביותר שמיישם רשימה מקושרת כפולה לאחסון האלמנטים שבתוכו. זה יכול לאחסן אלמנטים כפולים. הוא מיישם את ממשק Dequeue המורחבת על ידי ממשק Queue וממשק List. זה לא מסונכרן. כעת נראה כיצד ניתן לפתור את הבעיה שלנו שנידונה לעיל (קונספט 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);
    }
}

תְפוּקָה

רשימת מערך

זה פשוט מיישם את ממשק הרשימה. הוא שומר על סדר ההכנסה ומשתמש במערך דינמי לאחסון אלמנטים מסוגי נתונים שונים. ניתן לשכפל אלמנטים. הוא גם לא מסונכרן ויכול לאחסן ערכי Null. עכשיו בואו נראה את השיטות השונות שלו... אלו שימושיות כאשר איננו יודעים כמה רשומות או אלמנטים עלינו להכניס. בואו ניקח דוגמה של ספרייה שבה אנחנו לא יודעים כמה ספרים אנחנו צריכים לשמור. אז בכל פעם שיש לנו ספר, אנחנו צריכים להכניס אותו ל-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());
		}
	}
}

תְפוּקָה

HashSet

הוא מיישם את ממשק הסט ולעולם אינו מכיל ערכים כפולים. הוא מיישם את טבלת הגיבוב לאחסון הערכים. זה גם מאפשר ערכי null. הוא אף פעם לא שומר על סדר ההכנסה, אבל מספק את ביצועי הזמן הקבועים עבור הוספה , הסרה , גודל ומכיל שיטות . זה הכי טוב לפעולות חיפוש והוא לא מסונכרן.

דוגמא

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());
        }
    }
}

תְפוּקָה

כפי שאתה יכול לראות זה לא שומר על סדר ההכנסה.

ArrayDeque

הוא מיישם את ממשק Deque כך שהוא מאפשר פעולות משני הקצוות. זה לא מאפשר ערכי null. זה מהיר יותר מ-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);
       }
   }
}

תְפוּקָה

מפת גיבוב

זהו היישום של ממשק המפה המגובה בטבלת ה-hash. הוא מאחסן את צמדי המפתח-ערך. זה לא מאפשר ערכי null. זה לא מסונכרן. זה אף פעם לא מבטיח את סדר ההכנסה. הוא מספק ביצועי זמן קבועים עבור שיטות כמו get , and put . הביצועים שלו תלויים בשני גורמים - קיבולת ראשונית ומקדם עומס . קיבולת היא מספר הדליים בטבלת הגיבוב ולכן הקיבולת הראשונית היא מספר הדליים שהוקצו בזמן היצירה. מקדם העומס הוא המדד לכמה ניתן לאכלס טבלת hash לפני הגדלת הקיבולת שלה. שיטת ה-rehash משמשת להגדלת הקיבולת והיא מכפילה בעיקר את מספר הדליים.

דוגמא

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 collections framework, מהם הממשקים והמחלקות שלה וכיצד ליישם את המחלקות השונות שלה. אתה תמיד יכול להשתמש במסגרת זו כדי לצמצם את המאמצים שלך ב-Java. אל תהסס להתאמן ולחזור לכאן בכל פעם שתזדקק לסיוע נוסף. למידה מהנה!