1. מסגרת אוסף Java
2. היררכיה של מסגרת אוסף
3. ממשק אוסף
4. ממשק איטרטור

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

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

אוסף Java פירושו יחידה אחת של אובייקטים. מסגרת Java Collection מספקת ממשקים רבים (Set, List, Queue, Deque) ומחלקות ( רשימת מערך , וקטור, רשימה מקושרת , PriorityQueue , HashSet, LinkedHashSet, TreeSet).

מה זה אוסף ב-Java

אוסף מייצג יחידה אחת של אובייקטים, כלומר קבוצה.

מהי מסגרת ב-Java

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

מהי מסגרת אוסף

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

1. ממשקים והטמעות שלהם, כלומר, מחלקות
2. אַלגוֹרִיתְם

• מהן שתי הדרכים לחזור על האלמנטים של אוסף?
• מה ההבדל בין מחלקות ArrayList ל-LinkedList במסגרת אוסף?
• מה ההבדל בין מחלקות ArrayList ל-Vector במסגרת אוסף?
• מה ההבדל בין שיעורי HashSet ו-HashMap במסגרת אוסף?
• מה ההבדל בין HashMap לכיתה Hashtable?
• מה ההבדל בין איטרטור לממשק ספירה במסגרת אוסף?
• כיצד נוכל למיין את האלמנטים של אובייקט? מה ההבדל בין ממשקי Comparable לבין Comparator?
• מה עושה שיטת hashcode()?
• מה ההבדל בין אוסף Java לאוספי Java?

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

הבה נראה את ההיררכיה של מסגרת האוסף. ה java.util החבילה מכילה את כל שיעורים ו ממשקים עבור מסגרת הגבייה.

ממשק שיטות איסוף

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

ממשק איטרטור

שיטות ממשק איטרטור

יש רק שלוש שיטות בממשק Iterator. הם:

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

ממשק Iterable הוא ממשק השורש לכל מחלקות האוסף. ממשק ה-Collection מרחיב את ממשק Iterable ולכן כל תת המחלקות של ממשק Collection מיישמות גם את ממשק Iterable.

הוא מכיל רק שיטה מופשטת אחת. כְּלוֹמַר.,

 Iterator iterator() 

הוא מחזיר את האיטרטור על האלמנטים מסוג T.

windows.open javascript

ממשק אוסף

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

חלק מהשיטות של ממשק Collection הן Boolean add (Object obj), Boolean addAll ( Collection c), void clear() וכו' אשר מיושמות על ידי כל תת המחלקות של ממשק Collection.

ממשק רשימה

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

ממשק רשימה מיושם על ידי המחלקות ArrayList, LinkedList, Vector ו-Stack.

כדי להפעיל את ממשק הרשימה, עלינו להשתמש ב:

 List list1= new ArrayList(); List list2 = new LinkedList(); List list3 = new Vector(); List list4 = new Stack(); 

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

המחלקות המיישמות את ממשק הרשימה ניתנות להלן.

רשימת מערך

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

 import java.util.*; class TestJavaCollection1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Ravi');//Adding object in arraylist list.add('Vijay'); list.add('Ravi'); list.add('Ajay'); //Traversing list through Iterator Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 Ravi Vijay Ravi Ajay 

רשימה מקושרת

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

שקול את הדוגמה הבאה.

 import java.util.*; public class TestJavaCollection2{ public static void main(String args[]){ LinkedList al=new LinkedList(); al.add('Ravi'); al.add('Vijay'); al.add('Ravi'); al.add('Ajay'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 Ravi Vijay Ravi Ajay 

וֶקטוֹר

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

שקול את הדוגמה הבאה.

 import java.util.*; public class TestJavaCollection3{ public static void main(String args[]){ Vector v=new Vector(); v.add('Ayush'); v.add('Amit'); v.add('Ashish'); v.add('Garima'); Iterator itr=v.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 Ayush Amit Ashish Garima 

לַעֲרוֹם

המחסנית היא תת המחלקה של וקטור. הוא מיישם את מבנה הנתונים האחרון-ב-ראשון-out, כלומר, Stack. המחסנית מכילה את כל השיטות של מחלקה וקטור ומספקת גם את השיטות שלה כמו boolean push(), boolean peek(), boolean push(object o), שמגדיר את המאפיינים שלו.

שקול את הדוגמה הבאה.

 import java.util.*; public class TestJavaCollection4{ public static void main(String args[]){ Stack stack = new Stack(); stack.push('Ayush'); stack.push('Garvit'); stack.push('Amit'); stack.push('Ashish'); stack.push('Garima'); stack.pop(); Iterator itr=stack.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 Ayush Garvit Amit Ashish 

ממשק תור

ממשק התור שומר על סדר ראשון-ב-ראשון-out. ניתן להגדיר זאת כרשימה מסודרת המשמשת לאחסון האלמנטים שעומדים לעיבוד. ישנן מחלקות שונות כמו PriorityQueue, Deque ו- ArrayDeque המיישמת את ממשק ה-Queue.

ניתן ליצור ממשק תור כמו:

 Queue q1 = new PriorityQueue(); Queue q2 = new ArrayDeque(); 

ישנן מחלקות שונות המיישמות את ממשק ה-Queue, חלקן מובאות להלן.

PriorityQueue

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

שקול את הדוגמה הבאה.

 import java.util.*; public class TestJavaCollection5{ public static void main(String args[]){ PriorityQueue queue=new PriorityQueue(); queue.add('Amit Sharma'); queue.add('Vijay Raj'); queue.add('JaiShankar'); queue.add('Raj'); System.out.println('head:'+queue.element()); System.out.println('head:'+queue.peek()); System.out.println('iterating the queue elements:'); Iterator itr=queue.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } queue.remove(); queue.poll(); System.out.println('after removing two elements:'); Iterator itr2=queue.iterator(); while(itr2.hasNext()){ System.out.println(itr2.next()); } } } 

תְפוּקָה:

 head:Amit Sharma head:Amit Sharma iterating the queue elements: Amit Sharma Raj JaiShankar Vijay Raj after removing two elements: Raj Vijay Raj 

וגם הממשק

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

ניתן ליצור Deque כמו:

 Deque d = new ArrayDeque(); 

ArrayDeque

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

ArrayDeque מהיר יותר מ- ArrayList ו-Stack ואין לו הגבלות קיבולת.

שקול את הדוגמה הבאה.

 import java.util.*; public class TestJavaCollection6{ public static void main(String[] args) { //Creating Deque and adding elements Deque deque = new ArrayDeque(); deque.add('Gautam'); deque.add('Karan'); deque.add('Ajay'); //Traversing elements for (String str : deque) { System.out.println(str); } } } 

תְפוּקָה:

 Gautam Karan Ajay 

הגדר ממשק

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

ניתן ליצור את הסט כ:

 Set s1 = new HashSet(); Set s2 = new LinkedHashSet(); Set s3 = new TreeSet(); 

HashSet

מחלקה HashSet מיישמת Set Interface. הוא מייצג את האוסף שמשתמש בטבלת hash לאחסון. Hashing משמש לאחסון האלמנטים ב-HashSet. הוא מכיל פריטים ייחודיים.

שקול את הדוגמה הבאה.

 import java.util.*; public class TestJavaCollection7{ public static void main(String args[]){ //Creating HashSet and adding elements HashSet set=new HashSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); //Traversing elements Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 Vijay Ravi Ajay 

LinkedHashSet

מחלקה LinkedHashSet מייצגת את היישום LinkedList של Set Interface. זה מרחיב את מחלקת HashSet ומיישם ממשק Set. כמו HashSet, הוא מכיל גם אלמנטים ייחודיים. הוא שומר על סדר ההכנסה ומתיר רכיבים null.

שקול את הדוגמה הבאה.

 import java.util.*; public class TestJavaCollection8{ public static void main(String args[]){ LinkedHashSet set=new LinkedHashSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 Ravi Vijay Ajay 

ממשק SortedSet

SortedSet הוא הממשק החלופי של Set המספק סדר כולל של האלמנטים שלו. האלמנטים של SortedSet מסודרים בסדר עולה (עולה). ה-SortedSet מספק את השיטות הנוספות המעכבות את הסדר הטבעי של האלמנטים.

ניתן ליצור את ה-SortedSet כ:

 SortedSet set = new TreeSet(); 

TreeSet

מחלקת Java TreeSet מיישמת את ממשק ה-Set שמשתמש בעץ לאחסון. כמו HashSet, גם TreeSet מכיל אלמנטים ייחודיים. עם זאת, זמן הגישה והשליפה של TreeSet הוא די מהיר. האלמנטים ב-TreeSet מאוחסנים בסדר עולה.

שקול את הדוגמה הבאה:

 import java.util.*; public class TestJavaCollection9{ public static void main(String args[]){ //Creating and adding elements TreeSet set=new TreeSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); //traversing elements Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 Ajay Ravi Vijay 

1. מחלקה ArrayList
2. מחלקה LinkedList
3. ממשק רשימה
4. מחלקה HashSet
5. מחלקה LinkedHashSet
6. מחלקה TreeSet
7. שיעור PriorityQueue
8. ממשק מפה
9. שיעור HashMap
10. שיעור LinkedHashMap
11. שיעור TreeMap
12. שיעור Hastable
13. מִיוּן
14. ממשק בר השוואה
15. ממשק השוואה
16. שיעור מאפיינים ב-Java