Jáva Tömb lista osztály használja a dinamikus sor az elemek tárolására. Olyan, mint egy tömb, de van nincs méretkorlát . Bármikor hozzáadhatunk vagy eltávolíthatunk elemeket. Tehát sokkal rugalmasabb, mint a hagyományos tömb. Megtalálható a java.util csomag. Olyan, mint a vektor a C++-ban.

Az ArrayList Java-ban is tartalmazhat duplikált elemeket. A Lista felületet valósítja meg, így itt a Lista felület összes metódusát használhatjuk. Az ArrayList belsőleg fenntartja a beillesztési sorrendet.

Megörökli az AbstractList osztályt és implementálja Lista felület .

A Java ArrayList osztály legfontosabb pontjai a következők:

• A Java ArrayList osztály duplikált elemeket tartalmazhat.
• A Java ArrayList osztály fenntartja a beillesztési sorrendet.
• A Java ArrayList osztály nem szinkronizálva .
• A Java ArrayList véletlen hozzáférést tesz lehetővé, mivel a tömb index alapon működik.
• Az ArrayListben a manipuláció egy kicsit lassabb, mint a LinkedList Java-ban, mert sok eltolásnak kell történnie, ha bármely elemet eltávolítanak a tömblistából.
• A primitív típusokból (pl. int, float, char stb.) nem tudunk tömblistát készíteni. Ilyen esetekben a szükséges wrapper osztályt kell használni. Például:

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

• A Java ArrayList a méret alapján inicializálódik. A méret dinamikus a tömblistában, amely a listához hozzáadott vagy onnan eltávolított elemek függvényében változik.

Az ArrayList osztály hierarchiája

Amint a fenti diagramon látható, a Java ArrayList osztály kiterjeszti az AbstractList osztályt, amely megvalósítja a List interfészt. A Lista felület kiterjeszti a Gyűjtemény és Iterálható felületek hierarchikus sorrendben.

ArrayList osztálydeklaráció

Lássuk a java.util.ArrayList osztály deklarációját.

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

Az ArrayList konstruktorai

Az ArrayList módszerei

Java nem általános vs. Általános gyűjtemény

A Java gyűjtési keretrendszer nem volt általános a JDK 1.5 előtt. 1.5 óta általános.

Java új általános gyűjtemény lehetővé teszi, hogy csak egy típusú objektum legyen a gyűjteményben. Mostantól típusbiztonságos, így futásidőben nincs szükség typecastingra.

Lássuk a régi, nem általános példát a Java gyűjtemény létrehozására.

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

Lássuk a java gyűjtemény létrehozásának új általános példáját.

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

Egy általános gyűjteményben szögletes kapcsos zárójelben adjuk meg a típust. Az ArrayList most arra kényszerül, hogy az egyetlen megadott típusú objektumot tartalmazza. Ha más típusú objektumot próbál hozzáadni, akkor a fordítási idő hiba .

Ha többet szeretne megtudni a Java általános formáiról, kattintson ide Java Generics oktatóanyag .

Java ArrayList példa

Fájl név: 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); } } 

Kimenet:

[Mango, Apple, Banana, Grapes] 

Az ArrayList iterálása az Iterator segítségével

Lássunk egy példát az ArrayList elemek bejárására az Iterator felület segítségével.

Fájl név: ArrayListExample2.java

java oktatóanyag kezdőknek

 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 } } } 

Kimenet:

Mango Apple Banana Grapes 

Az ArrayList iterálása a For-each ciklus használatával

Nézzünk egy példát az ArrayList elemek bejárására a for-each ciklus használatával

Fájl név: 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); } } 

Kimenet:

Mango Apple Banana Grapes 

Szerezze be és állítsa be az ArrayList-et

A get() metódus visszaadja az elemet a megadott indexen, míg a set() metódus megváltoztatja az elemet.

Fájl név: 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); } } 

Kimenet:

Returning element: Apple Mango Dates Banana Grapes 

Az ArrayList rendezése

A java.util csomag egy használati osztályt biztosít Gyűjtemények , amely a statikus sort() metódussal rendelkezik. Használni a Collections.sort() módszerrel könnyen rendezhetjük az ArrayList-et.

Fájl név: 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); } } 

Kimenet:

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

A gyűjtemény elemeinek ismétlésének módjai Java nyelven

A gyűjteményelemeken többféleképpen is bejárható:

1. Iterator interfészen keresztül.
2. For-minden hurok szerint.
3. A ListIterator felülettel.
4. A for loop által.
5. A forEach() metódussal.
6. A forEachRemaining() metódussal.

Gyűjtemény iterálása a fennmaradó módokon

Lássunk egy példát az ArrayList elemek más módokon való bejárására

Fájl név: 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++)>

Kimenet:

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 

Felhasználó által definiált osztályobjektumok a Java ArrayListben

Lássunk egy példát, ahol a Student osztály objektumát egy tömblistában tároljuk.

alapvető java interjúkérdések

Fájl név: 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); } } } 

Kimenet:

 101 Sonoo 23 102 Ravi 21 103 Hanumat 25 

Java ArrayList szerializálási és deszerializációs példa

Nézzünk egy példát egy ArrayList objektum szerializálására, majd deszerializálására.

Fájl név: 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); } } } 

Kimenet:

 [Ravi, Vijay, Ajay] 

Java ArrayList példa elemek hozzáadásához

Itt különböző módokat látunk egy elem hozzáadására.

Fájl név: 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); } } 

Kimenet:

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 példa elemek eltávolítására

Itt különböző módokat látunk egy elem eltávolítására.

css csomagoló szöveg

Fájl név: 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); } } 

Kimenet:

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 példa a retainAll() metódusra

Fájl név: 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()); } } } 

Kimenet:

 iterating the elements after retaining the elements of al2 Ravi 

Java ArrayList példa az isEmpty() metódusra

Fájl név: 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()); } } 

Kimenet:

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

Java ArrayList Példa: Könyv

Lássunk egy ArrayList példát, ahol könyveket adunk a listához, és kinyomtatjuk az összes könyvet.

Fájl név: 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); } } } 

Kimenet:

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

Egy ArrayList mérete és kapacitása

A tömblista mérete és kapacitása az a két kifejezés, amelyet a kezdők zavarónak találnak. Nézzük meg ebben a részben néhány példa segítségével. Vegye figyelembe a következő kódrészletet.

Fájl név: 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()); } } 

Kimenet:

 The size of the array is: 0 

Magyarázat: A kimenetnek van értelme, mivel nem tettünk semmit a tömblistával. Most figyelje meg a következő programot.

Fájl név: 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()); } } 

Kimenet:

 The size of the array is: 0 

Magyarázat: Látjuk, hogy a méret továbbra is 0, és ennek oka az, hogy a 10-es szám a kapacitást jelenti, nem a méretet. Valójában a méret a tömbben lévő elemek teljes számát jelenti. Mivel egyetlen elemet sem adtunk hozzá, ezért a tömblista mérete mindkét programban nulla.

objektum a jsonobject java-ra

A kapacitás a tömblista által tartalmazható elemek teljes számát jelenti. Ezért egy tömblista kapacitása mindig nagyobb vagy egyenlő a tömblista méretével. Amikor hozzáadunk egy elemet a tömblistához, akkor ellenőrzi, hogy a tömblista mérete megegyezett-e a kapacitással vagy sem. Ha igen, akkor a tömblista kapacitása megnő. Tehát a fenti példában a kapacitás 10 lesz, amíg 10 elemet adunk a listához. Ha hozzáadjuk a 11-et^thelem, a kapacitás növekszik. Vegye figyelembe, hogy mindkét példában a tömblista kapacitása 10. Az első esetben a kapacitás 10, mert a tömblista alapértelmezett kapacitása 10. A második esetben kifejezetten megemlítettük, hogy a tömb kapacitása a lista a 10.

Megjegyzés: Nincs szabványos módszer annak megállapítására, hogy a kapacitás hogyan nő a tömblistában. Valójában a kapacitás növekedésének módja GDK-verziónként változik. Ezért ellenőrizni kell, hogy a kapacitásnövelő kód hogyan valósul meg a GDK-ban. Az ArrayList osztályban nincs olyan előre definiált metódus, amely visszaadja a tömblista kapacitását. Ezért a jobb megértés érdekében használja a Vector osztály kapacitás() metódusát. A méret és a kapacitás logikája megegyezik az ArrayList és a Vector osztályban.

Kapcsolódó témák

Az ArrayList rendezése Java-ban

Különbség az Array és az ArrayList között

Mikor kell használni az ArrayList-et és a LinkedList-et Java-ban

Az ArrayList és a LinkedList közötti különbség

Az ArrayList és a Vector közötti különbség

Hogyan hasonlítsunk össze két ArrayList-et Java-ban

Hogyan lehet megfordítani az ArrayList-et Java-ban

Mikor kell használni az ArrayList-et és a LinkedList-et Java-ban

Az ArrayList csak olvashatóvá tétele

Különbség a tömb hossza és az ArrayList mérete () között Java-ban

Az ArrayList szinkronizálása Java-ban

Hogyan lehet az ArrayList-et Array-re és az Array-t ArrayList-re konvertálni java-ban

Array vs ArrayList Java-ban

A Java ArrayList rendezése csökkenő sorrendben

Hogyan távolítsuk el a duplikációkat az ArrayList-ből Java-ban