TechCodeview

Java ArrayList klasse bruger en dynamisk array til opbevaring af elementerne. Det er ligesom en række, men der er ingen størrelsesbegrænsning . Vi kan tilføje eller fjerne elementer når som helst. Så det er meget mere fleksibelt end det traditionelle array. Den findes i java.util pakke. Det er ligesom Vector i C++.

ArrayList i Java kan også have de duplikerede elementer. Den implementerer List-grænsefladen, så vi kan bruge alle metoderne i List-grænsefladen her. ArrayList vedligeholder indsættelsesrækkefølgen internt.

Den arver klassen AbstractList og implementerer Listegrænseflade .

De vigtige punkter om Java ArrayList-klassen er:

• Java ArrayList-klassen kan indeholde duplikerede elementer.
• Java ArrayList-klassen opretholder indsættelsesrækkefølgen.
• Java ArrayList-klassen er ikke synkroniseret .
• Java ArrayList tillader vilkårlig adgang, fordi arrayet fungerer på indeksbasis.
• I ArrayList er manipulation en smule langsommere end LinkedList i Java, fordi der skal ske en masse skift, hvis et element fjernes fra arraylisten.
• Vi kan ikke oprette en array-liste over de primitive typer, såsom int, float, char osv. Det er påkrævet at bruge den påkrævede wrapper-klasse i sådanne tilfælde. For eksempel:

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

• Java ArrayList bliver initialiseret af størrelsen. Størrelsen er dynamisk i arraylisten, som varierer afhængigt af de elementer, der tilføjes eller fjernes fra listen.

Hierarki af ArrayList-klassen

Som vist i diagrammet ovenfor, udvider Java ArrayList-klassen AbstractList-klassen, som implementerer List-grænsefladen. Liste-grænsefladen udvider Kollektion og Iterable grænseflader i hierarkisk rækkefølge.

ArrayList klasseerklæring

Lad os se erklæringen for klassen java.util.ArrayList.

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

Konstruktører af ArrayList

Metoder til ArrayList

Java ikke-generisk vs. Generisk samling

Java-samlingsramme var ikke-generisk før JDK 1.5. Siden 1,5 er det generisk.

Java ny generisk samling giver dig mulighed for kun at have én type objekt i en samling. Nu er den typesikker, så typecasting er ikke påkrævet under kørsel.

Lad os se det gamle ikke-generiske eksempel på at skabe en Java-samling.

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

Lad os se det nye generiske eksempel på at skabe java-samling.

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

I en generisk samling angiver vi typen i kantede seler. Nu er ArrayList tvunget til at have den eneste specificerede type objekt i sig. Hvis du forsøger at tilføje en anden type objekt, giver det en kompileringstidsfejl .

For mere information om generiske Java, klik her Java Generics Tutorial .

Eksempel på Java ArrayList

Filnavn: 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); } } 

Produktion:

[Mango, Apple, Banana, Grapes] 

Iterering af ArrayList ved hjælp af Iterator

Lad os se et eksempel på at krydse ArrayList-elementer ved hjælp af Iterator-grænsefladen.

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

Produktion:

Mango Apple Banana Grapes 

Itererende ArrayList ved hjælp af For-each loop

Lad os se et eksempel for at krydse ArrayList-elementerne ved hjælp af for-each-løkken

Filnavn: 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); } } 

Produktion:

Mango Apple Banana Grapes 

Hent og indstil ArrayList

Det get() metode returnerer elementet ved det angivne indeks, hvorimod set() metode ændrer elementet.

Filnavn: 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); } } 

Produktion:

Returning element: Apple Mango Dates Banana Grapes 

Sådan sorteres ArrayList

Det java.util pakken giver en hjælpeklasse Samlinger , som har den statiske metode sort(). Bruger Collections.sort() metode, kan vi nemt sortere ArrayList.

Filnavn: 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); } } 

Produktion:

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

Måder at gentage elementerne i samlingen i Java

Der er forskellige måder at krydse samlingselementerne på:

1. Ved Iterator-grænseflade.
2. Ved hver sløjfe.
3. Ved ListIterator-grænseflade.
4. Ved for loop.
5. Ved forEach() metode.
6. Ved forEachRemaining() metode.

Itererende samling på de resterende måder

Lad os se et eksempel for at krydse ArrayList-elementerne på andre måder

Filnavn: 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++)>

Produktion:

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 

Brugerdefinerede klasseobjekter i Java ArrayList

Lad os se et eksempel, hvor vi gemmer Student-klasseobjekt i en matrixliste.

Filnavn: 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); } } } 

Produktion:

 101 Sonoo 23 102 Ravi 21 103 Hanumat 25 

Eksempel på Java ArrayList-serialisering og deserialisering

Lad os se et eksempel på at serialisere et ArrayList-objekt og derefter deserialisere det.

Filnavn: 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); } } } 

Produktion:

 [Ravi, Vijay, Ajay] 

Java ArrayList eksempel for at tilføje elementer

Her ser vi forskellige måder at tilføje et element på.

Filnavn: 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); } } 

Produktion:

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 eksempel for at fjerne elementer

Her ser vi forskellige måder at fjerne et element på.

css midterknap

Filnavn: 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); } } 

Produktion:

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 eksempel på retainAll() metode

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

Produktion:

 iterating the elements after retaining the elements of al2 Ravi 

Java ArrayList eksempel på isEmpty() metode

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

Produktion:

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

Java ArrayList Eksempel: Bog

Lad os se et ArrayList-eksempel, hvor vi tilføjer bøger til listen og udskriver alle bøgerne.

Filnavn: 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); } } } 

Produktion:

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

Størrelse og kapacitet af en ArrayList

Størrelse og kapacitet af en array-liste er de to udtryk, som begyndere finder forvirrende. Lad os forstå det i dette afsnit ved hjælp af nogle eksempler. Overvej følgende kodestykke.

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

Produktion:

 The size of the array is: 0 

Forklaring: Outputtet giver mening, da vi ikke har gjort noget med arraylisten. Overhold nu følgende program.

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

Produktion:

 The size of the array is: 0 

Forklaring: Vi ser, at størrelsen stadig er 0, og årsagen til dette er, at tallet 10 repræsenterer kapaciteten uden størrelsen. Faktisk repræsenterer størrelsen det samlede antal elementer, der er til stede i arrayet. Da vi ikke har tilføjet noget element, er størrelsen af ​​arraylisten derfor nul i begge programmer.

Kapacitet repræsenterer det samlede antal elementer, arraylisten kan indeholde. Derfor er kapaciteten af ​​en matrixliste altid større end eller lig med størrelsen af ​​matrixlisten. Når vi tilføjer et element til arraylisten, tjekker det om størrelsen af ​​arraylisten er blevet lig med kapaciteten eller ej. Hvis ja, så øges arraylistens kapacitet. Så i ovenstående eksempel vil kapaciteten være 10 indtil 10 elementer tilføjes til listen. Når vi tilføjer 11^thelement, øges kapaciteten. Bemærk, at i begge eksempler er arraylistens kapacitet 10. I det første tilfælde er kapaciteten 10, fordi arraylistens standardkapacitet er 10. I det andet tilfælde har vi eksplicit nævnt, at arrayets kapacitet listen er 10.

Bemærk: Der er ingen standardmetode til at fortælle, hvordan kapaciteten øges i arraylisten. Faktisk varierer den måde, hvorpå kapaciteten øges, fra den ene GDK-version til den anden version. Derfor er det påkrævet at kontrollere, hvordan kapacitetsforøgende kode implementeres i GDK. Der er ingen foruddefineret metode i ArrayList-klassen, der returnerer arraylistens kapacitet. Derfor, for bedre forståelse, brug kapacitet()-metoden i Vector-klassen. Logikken i størrelsen og kapaciteten er den samme i ArrayList-klassen og Vector-klassen.

Relaterede emner

Sådan sorteres ArrayList i Java

Forskellen mellem Array og ArrayList

Hvornår skal ArrayList og LinkedList bruges i Java

Forskellen mellem ArrayList og LinkedList

Forskellen mellem ArrayList og Vector

Sådan sammenlignes Two ArrayList i Java

Sådan vendes ArrayList i Java

Hvornår skal ArrayList og LinkedList bruges i Java

Sådan gør du ArrayList skrivebeskyttet

Forskellen mellem længden af ​​array og size() af ArrayList i Java

Sådan synkroniseres ArrayList i Java

Sådan konverteres ArrayList til Array og Array til ArrayList i java

Array vs ArrayList i Java

Sådan sorteres Java ArrayList i faldende rækkefølge

Sådan fjerner du dubletter fra ArrayList i Java