Java רשימת מערך הכיתה משתמשת ב-a דִינָמִי מַעֲרָך לאחסון האלמנטים. זה כמו מערך, אבל יש ללא הגבלת גודל . אנו יכולים להוסיף או להסיר אלמנטים בכל עת. אז, זה הרבה יותר גמיש מהמערך המסורתי. זה נמצא ב java.util חֲבִילָה. זה כמו הוקטור ב-C++.

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

הוא יורש את המחלקה AbstractList ומיישם ממשק רשימה .

הנקודות החשובות לגבי מחלקת Java ArrayList הן:

קרא מקובץ csv ב-java

• מחלקה Java ArrayList יכולה להכיל אלמנטים כפולים.
• מחלקה Java ArrayList שומרת על סדר ההכנסה.
• מחלקת Java ArrayList אינה מסונכרן .
• Java ArrayList מאפשר גישה אקראית מכיוון שהמערך עובד על בסיס אינדקס.
• ב-ArrayList, המניפולציה קצת יותר איטית מה-LinkedList ב-Java מכיוון שהרבה תזוזה צריכה להתרחש אם אלמנט כלשהו יוסר מרשימת המערך.
• אנחנו לא יכולים ליצור רשימת מערך של הטיפוסים הפרימיטיביים, כגון int, float, char וכו'. נדרש להשתמש במחלקת העטיפה הנדרשת במקרים כאלה. לדוגמה:

 ArrayList al = ArrayList(); // does not work ArrayList al = new ArrayList(); // works fine 

• Java ArrayList מאתחל לפי הגודל. הגודל הוא דינמי ברשימת המערך, המשתנה בהתאם לרכיבים שמתווספים או מוסרים מהרשימה.

היררכיה של מחלקה ArrayList

כפי שמוצג בתרשים לעיל, מחלקת Java ArrayList מרחיבה את מחלקת AbstractList המיישמת את ממשק List. ממשק הרשימה מרחיב את אוסף וממשקי איטרציה בסדר היררכי.

הצהרת מחלקה ArrayList

בוא נראה את ההצהרה עבור המחלקה java.util.ArrayList.

 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable 

בונים של ArrayList

שיטות של ArrayList

Java לא גנרי לעומת אוסף גנרי

מסגרת אוסף Java לא הייתה כללית לפני JDK 1.5. מאז 1.5, זה גנרי.

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

בואו נראה את הדוגמה הישנה הלא-גנרית של יצירת אוסף Java.

 ArrayList list=new ArrayList();//creating old non-generic arraylist 

בואו נראה את הדוגמה הגנרית החדשה ליצירת אוסף Java.

 ArrayList list=new ArrayList();//creating new generic arraylist 

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

למידע נוסף על Java גנריות, לחץ כאן מדריך ג'אווה גנרי .

דוגמה של Java ArrayList

שם קובץ: ArrayListExample1.java

 import java.util.*; public class ArrayListExample1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Printing the arraylist object System.out.println(list); } } 

תְפוּקָה:

[Mango, Apple, Banana, Grapes] 

איטרציה של ArrayList באמצעות איטרטור

בוא נראה דוגמה לחצות אלמנטים של ArrayList באמצעות ממשק Iterator.

שם קובץ: ArrayListExample2.java

 import java.util.*; public class ArrayListExample2{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through Iterator Iterator itr=list.iterator();//getting the Iterator while(itr.hasNext()){//check if iterator has the elements System.out.println(itr.next());//printing the element and move to next } } } 

תְפוּקָה:

Mango Apple Banana Grapes 

איטרציה של ArrayList באמצעות For-each loop

בוא נראה דוגמה למעבר בין רכיבי ArrayList באמצעות הלולאה for-each

שם קובץ: ArrayListExample3.java

 import java.util.*; public class ArrayListExample3{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through for-each loop for(String fruit:list) System.out.println(fruit); } } 

תְפוּקָה:

Mango Apple Banana Grapes 

קבל והגדר ArrayList

ה שיטת get() מחזירה את האלמנט באינדקס שצוין, בעוד שה- שיטת set() משנה את האלמנט.

שם קובץ: ArrayListExample4.java

 import java.util.*; public class ArrayListExample4{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Mango'); al.add('Apple'); al.add('Banana'); al.add('Grapes'); //accessing the element System.out.println('Returning element: '+al.get(1));//it will return the 2nd element, because index starts from 0 //changing the element al.set(1,'Dates'); //Traversing list for(String fruit:al) System.out.println(fruit); } } 

תְפוּקָה:

Returning element: Apple Mango Dates Banana Grapes 

כיצד למיין ArrayList

ה java.util החבילה מספקת מחלקת שירות אוספים , שיש לו את השיטה הסטטית sort(). משתמש ב Collections.sort() בשיטה, נוכל למיין את ArrayList בקלות.

שם קובץ: SortArrayList.java

 import java.util.*; class SortArrayList{ public static void main(String args[]){ //Creating a list of fruits List list1=new ArrayList(); list1.add('Mango'); list1.add('Apple'); list1.add('Banana'); list1.add('Grapes'); //Sorting the list Collections.sort(list1); //Traversing list through the for-each loop for(String fruit:list1) System.out.println(fruit); System.out.println('Sorting numbers...'); //Creating a list of numbers List list2=new ArrayList(); list2.add(21); list2.add(11); list2.add(51); list2.add(1); //Sorting the list Collections.sort(list2); //Traversing list through the for-each loop for(Integer number:list2) System.out.println(number); } } 

תְפוּקָה:

Apple Banana Grapes Mango Sorting numbers... 1 11 21 51 

דרכים לחזור על מרכיבי האוסף בג'אווה

ישנן דרכים שונות לעבור את מרכיבי האוסף:

1. לפי ממשק איטרטור.
2. לפי לכל לולאה.
3. לפי ממשק ListIterator.
4. מאת עבור לולאה.
5. לפי שיטת forEach()
6. לפי שיטת forEachRemaining()

איטרציה של אוסף בדרכים שנותרו

בוא נראה דוגמה למעבר בין רכיבי ArrayList בדרכים אחרות

שם קובץ: ArrayList4.java

 import java.util.*; class ArrayList4{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add(&apos;Ravi&apos;);//Adding object in arraylist list.add(&apos;Vijay&apos;); list.add(&apos;Ravi&apos;); list.add(&apos;Ajay&apos;); System.out.println(&apos;Traversing list through List Iterator:&apos;); //Here, element iterates in reverse order ListIterator list1=list.listIterator(list.size()); while(list1.hasPrevious()) { String str=list1.previous(); System.out.println(str); } System.out.println(&apos;Traversing list through for loop:&apos;); for(int i=0;i<list.size();i++) { system.out.println(list.get(i)); } system.out.println('traversing list through foreach() method:'); the method is a new feature, introduced in java 8. list.foreach(a->{ //Here, we are using lambda expression System.out.println(a); }); System.out.println(&apos;Traversing list through forEachRemaining() method:&apos;); Iterator itr=list.iterator(); itr.forEachRemaining(a-&gt; //Here, we are using lambda expression { System.out.println(a); }); } } </list.size();i++)>

תְפוּקָה:

Traversing list through List Iterator: Ajay Ravi Vijay Ravi Traversing list through for loop: Ravi Vijay Ravi Ajay Traversing list through forEach() method: Ravi Vijay Ravi Ajay Traversing list through forEachRemaining() method: Ravi Vijay Ravi Ajay 

אובייקטי מחלקה המוגדרים על ידי המשתמש ב-Java ArrayList

בוא נראה דוגמה שבה אנו מאחסנים אובייקט כיתת Student ברשימת מערך.

שם קובץ: ArrayList5.java

 class Student{ int rollno; String name; int age; Student(int rollno,String name,int age){ this.rollno=rollno; this.name=name; this.age=age; } } 

 import java.util.*; class ArrayList5{ public static void main(String args[]){ //Creating user-defined class objects Student s1=new Student(101,'Sonoo',23); Student s2=new Student(102,'Ravi',21); Student s2=new Student(103,'Hanumat',25); //creating arraylist ArrayList al=new ArrayList(); al.add(s1);//adding Student class object al.add(s2); al.add(s3); //Getting Iterator Iterator itr=al.iterator(); //traversing elements of ArrayList object while(itr.hasNext()){ Student st=(Student)itr.next(); System.out.println(st.rollno+' '+st.name+' '+st.age); } } } 

תְפוּקָה:

 101 Sonoo 23 102 Ravi 21 103 Hanumat 25 

Java ArrayList Serialization ו-Deserialization דוגמה

בוא נראה דוגמה להסדרת אובייקט ArrayList ולאחר מכן לבטל אותו.

שם קובץ: ArrayList6.java

 import java.io.*; import java.util.*; class ArrayList6 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); try { //Serialization FileOutputStream fos=new FileOutputStream('file'); ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeObject(al); fos.close(); oos.close(); //Deserialization FileInputStream fis=new FileInputStream('file'); ObjectInputStream ois=new ObjectInputStream(fis); ArrayList list=(ArrayList)ois.readObject(); System.out.println(list); }catch(Exception e) { System.out.println(e); } } } 

תְפוּקָה:

 [Ravi, Vijay, Ajay] 

דוגמה של Java ArrayList להוספת אלמנטים

כאן, אנו רואים דרכים שונות להוסיף אלמנט.

שם קובץ: ArrayList7.java

 import java.util.*; class ArrayList7{ public static void main(String args[]){ ArrayList al=new ArrayList(); System.out.println('Initial list of elements: '+al); //Adding elements to the end of the list al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After invoking add(E e) method: '+al); //Adding an element at the specific position al.add(1, 'Gaurav'); System.out.println('After invoking add(int index, E element) method: '+al); ArrayList al2=new ArrayList(); al2.add('Sonoo'); al2.add('Hanumat'); //Adding second list elements to the first list al.addAll(al2); System.out.println('After invoking addAll(Collection c) method: '+al); ArrayList al3=new ArrayList(); al3.add('John'); al3.add('Rahul'); //Adding second list elements to the first list at specific position al.addAll(1, al3); System.out.println('After invoking addAll(int index, Collection c) method: '+al); } } 

תְפוּקָה:

Initial list of elements: [] After invoking add(E e) method: [Ravi, Vijay, Ajay] After invoking add(int index, E element) method: [Ravi, Gaurav, Vijay, Ajay] After invoking addAll(Collection c) method: [Ravi, Gaurav, Vijay, Ajay, Sonoo, Hanumat] After invoking addAll(int index, Collection c) method: [Ravi, John, Rahul, Gaurav, Vijay, Ajay, Sonoo, Hanumat] 

דוגמה של Java ArrayList להסרת אלמנטים

כאן, אנו רואים דרכים שונות להסיר אלמנט.

שם קובץ: ArrayList8.java

 import java.util.*; class ArrayList8 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); al.add('Anuj'); al.add('Gaurav'); System.out.println('An initial list of elements: '+al); //Removing specific element from arraylist al.remove('Vijay'); System.out.println('After invoking remove(object) method: '+al); //Removing element on the basis of specific position al.remove(0); System.out.println('After invoking remove(index) method: '+al); //Creating another arraylist ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); //Adding new elements to arraylist al.addAll(al2); System.out.println('Updated list : '+al); //Removing all the new elements from arraylist al.removeAll(al2); System.out.println('After invoking removeAll() method: '+al); //Removing elements on the basis of specified condition al.removeIf(str -> str.contains('Ajay')); //Here, we are using Lambda expression System.out.println('After invoking removeIf() method: '+al); //Removing all the elements available in the list al.clear(); System.out.println('After invoking clear() method: '+al); } } 

תְפוּקָה:

An initial list of elements: [Ravi, Vijay, Ajay, Anuj, Gaurav] After invoking remove(object) method: [Ravi, Ajay, Anuj, Gaurav] After invoking remove(index) method: [Ajay, Anuj, Gaurav] Updated list : [Ajay, Anuj, Gaurav, Ravi, Hanumat] After invoking removeAll() method: [Ajay, Anuj, Gaurav] After invoking removeIf() method: [Anuj, Gaurav] After invoking clear() method: [] 

דוגמה של Java ArrayList לשיטת retainAll()‎

שם קובץ: ArrayList9.java

 import java.util.*; class ArrayList9{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); al.retainAll(al2); System.out.println('iterating the elements after retaining the elements of al2'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 iterating the elements after retaining the elements of al2 Ravi 

דוגמה של Java ArrayList לשיטת isEmpty()‎

שם קובץ: ArrayList4.java

 import java.util.*; class ArrayList10{ public static void main(String [] args) { ArrayList al=new ArrayList(); System.out.println('Is ArrayList Empty: '+al.isEmpty()); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After Insertion'); System.out.println('Is ArrayList Empty: '+al.isEmpty()); } } 

תְפוּקָה:

Is ArrayList Empty: true After Insertion Is ArrayList Empty: false 

Java ArrayList דוגמה: ספר

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

שם קובץ: ArrayListExample20.java

 import java.util.*; class Book { int id; String name,author,publisher; int quantity; public Book(int id, String name, String author, String publisher, int quantity) { this.id = id; this.name = name; this.author = author; this.publisher = publisher; this.quantity = quantity; } } public class ArrayListExample20 { public static void main(String[] args) { //Creating list of Books List list=new ArrayList(); //Creating Books Book b1=new Book(101,'Let us C','Yashwant Kanetkar','BPB',8); Book b2=new Book(102,'Data Communications and Networking','Forouzan','Mc Graw Hill',4); Book b3=new Book(103,'Operating System','Galvin','Wiley',6); //Adding Books to list list.add(b1); list.add(b2); list.add(b3); //Traversing list for(Book b:list){ System.out.println(b.id+' '+b.name+' '+b.author+' '+b.publisher+' '+b.quantity); } } } 

תְפוּקָה:

101 Let us C Yashwant Kanetkar BPB 8 102 Data Communications and Networking Forouzan Mc Graw Hill 4 103 Operating System Galvin Wiley 6 

גודל וקיבולת של ArrayList

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

שם קובץ: SizeCapacity.java

מארח לינוקס

 import java.util.*; public class SizeCapacity { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(); System.out.println('The size of the array is: ' + al.size()); } } 

תְפוּקָה:

 The size of the array is: 0 

הֶסבֵּר: הפלט הגיוני מכיוון שלא עשינו שום דבר עם רשימת המערך. כעת צפו בתוכנית הבאה.

שם קובץ: SizeCapacity1.java

 import java.util.*; public class SizeCapacity1 { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(10); System.out.println('The size of the array is: ' + al.size()); } } 

תְפוּקָה:

 The size of the array is: 0 

הֶסבֵּר: אנו רואים שהגודל עדיין 0, והסיבה מאחורי זה היא המספר 10 מייצג את הקיבולת ללא הגודל. למעשה, הגודל מייצג את המספר הכולל של האלמנטים הקיימים במערך. מכיוון שלא הוספנו שום אלמנט, לכן, גודל רשימת המערך הוא אפס בשתי התוכניות.

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

הערה: אין שום שיטה סטנדרטית לספר כיצד גדל הקיבולת ברשימת המערך. למעשה, האופן שבו גדל הקיבולת משתנה מגרסת GDK אחת לגרסה השנייה. לכן, נדרש לבדוק את האופן שבו קוד מגדיל את הקיבולת מיושם ב-GDK. אין שום שיטה מוגדרת מראש במחלקה ArrayList שמחזירה את הקיבולת של רשימת המערך. לכן, להבנה טובה יותר, השתמש בשיטת capacity() של המחלקה Vector. ההיגיון של הגודל והקיבולת זהה במחלקה ArrayList ובמחלקה Vector.

נושאים קשורים

כיצד למיין ArrayList ב-Java

ההבדל בין Array ל- ArrayList

מתי להשתמש ב-ArrayList וב-LinkedList ב-Java

ההבדל בין ArrayList ל-LinkedList

ההבדל בין ArrayList לוקטור

כיצד להשוות שני ArrayList ב-Java

כיצד להפוך ArrayList ב-Java

מתי להשתמש ב-ArrayList וב-LinkedList ב-Java

כיצד להפוך את ArrayList לקריאה בלבד

ההבדל בין אורך המערך לבין size() של ArrayList ב-Java

כיצד לסנכרן ArrayList ב-Java

כיצד להמיר ArrayList למערך ומערך ל-ArrayList ב-java

מערך לעומת ArrayList ב-Java

כיצד למיין Java ArrayList בסדר יורד

כיצד להסיר כפילויות מ-ArrayList ב-Java