TechCodeview

Java ArrayList klass använder en dynamisk array för att lagra elementen. Det är som en array, men det finns ingen storleksbegränsning . Vi kan lägga till eller ta bort element när som helst. Så den är mycket mer flexibel än den traditionella arrayen. Den finns i java.util paket. Det är som vektorn i C++.

ArrayList i Java kan också ha dubblettelementen. Den implementerar List-gränssnittet så att vi kan använda alla metoder för List-gränssnittet här. ArrayList upprätthåller insättningsordningen internt.

Den ärver klassen AbstractList och implementerar Listgränssnitt .

De viktiga punkterna om Java ArrayList-klassen är:

java stackar

• Java ArrayList-klassen kan innehålla dubbletter av element.
• Java ArrayList-klassen upprätthåller insättningsordningen.
• Java ArrayList-klassen är icke synkroniserad .
• Java ArrayList tillåter slumpmässig åtkomst eftersom arrayen fungerar på indexbasis.
• I ArrayList är manipulation lite långsammare än LinkedList i Java eftersom en hel del skiftningar måste ske om något element tas bort från arraylistan.
• Vi kan inte skapa en arraylista över de primitiva typerna, såsom int, float, char, etc. Det krävs att man använder den erforderliga wrapperklassen i sådana fall. Till exempel:

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

• Java ArrayList initieras av storleken. Storleken är dynamisk i arraylistan, som varierar beroende på vilka element som läggs till eller tas bort från listan.

Hierarki för ArrayList-klassen

Som visas i diagrammet ovan utökar Java ArrayList-klassen AbstractList-klassen som implementerar List-gränssnittet. Listgränssnittet utökar Samling och Itererbara gränssnitt i hierarkisk ordning.

ArrayList klassdeklaration

Låt oss se deklarationen för klassen java.util.ArrayList.

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

Konstruktörer av ArrayList

Metoder för ArrayList

Java Icke-generisk vs. Generisk samling

Java-samlingsramverket var icke-generiskt före JDK 1.5. Sedan 1,5 är det generiskt.

Javas nya generiska samling låter dig bara ha en typ av objekt i en samling. Nu är det typsäkert, så typcasting krävs inte under körning.

Låt oss se det gamla icke-generiska exemplet på att skapa en Java-samling.

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

Låt oss se det nya generiska exemplet på att skapa en java-samling.

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

I en generisk samling anger vi typen i vinkelhängslen. Nu är ArrayList tvungen att ha den enda specificerade typen av objekt i sig. Om du försöker lägga till en annan typ av objekt ger det en fel vid kompilering .

För mer information om generika Java, klicka här Självstudie för Java Generics .

Exempel på Java ArrayList

Filnamn: 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] 

Itererar ArrayList med Iterator

Låt oss se ett exempel för att gå igenom ArrayList-element med Iterator-gränssnittet.

Filnamn: 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 

Itererar ArrayList med For-each loop

Låt oss se ett exempel för att gå igenom ArrayList-elementen med hjälp av for-each-loopen

Filnamn: 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 

Hämta och ställ in ArrayList

De get() metoden returnerar elementet vid det angivna indexet, medan set() metod ändrar elementet.

Filnamn: 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 

Hur man sorterar ArrayList

De java.util paketet tillhandahåller en verktygsklass Samlingar , som har den statiska metoden sort(). Använda Collections.sort() metod kan vi enkelt sortera ArrayList.

Filnamn: 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 

Sätt att iterera elementen i samlingen i Java

Det finns olika sätt att gå igenom samlingselementen:

1. Genom Iterator-gränssnitt.
2. För varje slinga.
3. Genom ListIterator-gränssnitt.
4. Av för loop.
5. Med metoden forEach().
6. Genom metoden forEachRemaining().

Itererande samling genom återstående sätt

Låt oss se ett exempel för att gå igenom ArrayList-elementen på andra sätt

Filnamn: 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 

Användardefinierade klassobjekt i Java ArrayList

Låt oss se ett exempel där vi lagrar Studentklassobjekt i en arraylista.

Filnamn: 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 

Java ArrayList Serialisering och deserialisering Exempel

Låt oss se ett exempel för att serialisera ett ArrayList-objekt och sedan deserialisera det.

Filnamn: 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 exempel för att lägga till element

Här ser vi olika sätt att lägga till ett element.

Filnamn: 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 exempel för att ta bort element

Här ser vi olika sätt att ta bort ett element.

Filnamn: 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 exempel på retainAll()-metoden

Filnamn: 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 exempel på isEmpty()-metoden

Filnamn: 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 Exempel: Bok

Låt oss se ett ArrayList-exempel där vi lägger till böcker i listan och skriver ut alla böckerna.

Filnamn: 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 

Storlek och kapacitet för en ArrayList

Storlek och kapacitet för en arraylista är de två termer som nybörjare tycker är förvirrande. Låt oss förstå det i det här avsnittet med hjälp av några exempel. Tänk på följande kodavsnitt.

Filnamn: 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 

Förklaring: Utdata är vettigt eftersom vi inte har gjort något med arraylistan. Observera nu följande program.

Filnamn: 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 

Förklaring: Vi ser att storleken fortfarande är 0, och anledningen till detta är att siffran 10 representerar kapaciteten ingen storlek. Faktum är att storleken representerar det totala antalet element som finns i arrayen. Eftersom vi inte har lagt till något element är därför storleken på arraylistan noll i båda programmen.

Kapacitet representerar det totala antalet element som arraylistan kan innehålla. Därför är kapaciteten för en matrislista alltid större än eller lika med storleken på matrislistan. När vi lägger till ett element i arraylistan kontrollerar det om storleken på arraylistan har blivit lika med kapaciteten eller inte. Om ja, ökar kapaciteten för arraylistan. Så i exemplet ovan kommer kapaciteten att vara 10 tills 10 element läggs till i listan. När vi lägger till 11^thelement ökar kapaciteten. Observera att i båda exemplen är arraylistans kapacitet 10. I det första fallet är kapaciteten 10 eftersom standardkapaciteten för arraylistan är 10. I det andra fallet har vi uttryckligen nämnt att arrayens kapacitet listan är 10.

Obs: Det finns ingen standardmetod för att berätta hur kapaciteten ökar i arraylistan. Faktum är att hur kapaciteten ökar varierar från en GDK-version till en annan. Därför är det nödvändigt att kontrollera hur kapacitetsökningar kod implementeras i GDK. Det finns ingen fördefinierad metod i klassen ArrayList som returnerar kapaciteten för arraylistan. För bättre förståelse, använd därför method() för klassen Vector. Logiken för storleken och kapaciteten är densamma i klassen ArrayList och klassen Vector.

Relaterade ämnen

Hur man sorterar ArrayList i Java

Skillnaden mellan Array och ArrayList

När ska man använda ArrayList och LinkedList i Java

Skillnaden mellan ArrayList och LinkedList

Skillnaden mellan ArrayList och Vector

Hur man jämför Two ArrayList i Java

python os listdir

Hur man vänder ArrayList i Java

När ska man använda ArrayList och LinkedList i Java

Hur man gör ArrayList skrivskyddad

Skillnaden mellan längden på arrayen och size() på ArrayList i Java

Hur man synkroniserar ArrayList i Java

Hur man konverterar ArrayList till Array och Array till ArrayList i java

Array vs ArrayList i Java

Hur man sorterar Java ArrayList i fallande ordning

Hur man tar bort dubbletter från ArrayList i Java