Java ArrayList är en del av Java samlingsram och det är en klass av java.util-paketet. Det ger oss dynamiska arrayer i Java. Det kan dock vara långsammare än vanliga arrayer men kan vara till hjälp i program där mycket manipulation i arrayen behövs. Denna klass finns i java.util paket. Den huvudsakliga fördelen med ArrayList i Java är att om vi deklarerar en array måste vi nämna storleken, men i ArrayList behövs det inte nämna storleken på ArrayList. Om du vill nämna storleken så kan du göra det.

Innehållsförteckning

• Vad är ArrayList i Java?
• Exempel på Java ArrayList
• Viktiga funktioner i ArrayList i Java
• Konstruktörer i ArrayList
• ArrayList i Java-metoder
• Operationer som utförs i ArrayList
• Java ArrayLists komplexitet
• Fördelar med Java ArrayList
• Nackdelar med Java ArrayList
• Slutsats
• Vanliga frågor om ArrayList

Vad är ArrayList i Java?

ArrayList är en Java-klass implementerad med hjälp av List-gränssnittet. Java ArrayList tillhandahåller, som namnet antyder, funktionaliteten hos en dynamisk array där storleken inte är fixerad som en array. Dessutom, som en del av samlingsramverket, har den många funktioner som inte är tillgängliga med arrayer.

Illustration:

Låt oss kolla på ArrayList med heltalsobjekttypen lagrad i den med en bild.

mvc java

Exempel på Java ArrayList

Exempel 1: Följande implementering visar hur man skapar och använder en ArrayList med ett omnämnande av dess storlek.

// Java program to demonstrate the // working of ArrayList import java.io.*; import java.util.*; class ArrayListExample {  public static void main(String[] args)  {  // Size of the  // ArrayList  int n = 5;  // Declaring the ArrayList with  // initial size n  ArrayList arr1 = ny ArrayList (n);  // Deklarera ArrayList ArrayList arr2 = ny ArrayList ();  // Skriver ut ArrayList System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  // Lägga till nya element i // slutet av listan för (int i = 1; i<= n; i++) {  arr1.add(i);  arr2.add(i);  }  // Printing the ArrayList  System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  } }>

Array 1:[] Array 2:[] Array 1:[1, 2, 3, 4, 5] Array 2:[1, 2, 3, 4, 5]>

Förklaring av ovanstående program:

ArrayList är en dynamisk array och vi behöver inte specificera storleken när vi skapar den, storleken på arrayen ökar automatiskt när vi dynamiskt lägger till och tar bort objekt. Även om den faktiska biblioteksimplementeringen kan vara mer komplex, är följande en mycket grundläggande idé som förklarar hur arrayen fungerar när arrayen blir full och om vi försöker lägga till ett objekt:

• Skapar ett större minne på heap-minne (till exempel minne av dubbel storlek).
• Kopierar de aktuella minneselementen till det nya minnet.
• Det nya objektet läggs till nu eftersom det finns större minne tillgängligt nu.
• Radera det gamla minnet.

Viktiga funktioner i ArrayList i Java

• ArrayList ärver Abstrakt lista klass och implementerar Listgränssnitt .
• ArrayList initieras efter storlek. Storleken ökar dock automatiskt om samlingen växer eller krymper om föremål tas bort från samlingen.
• Java ArrayList låter oss komma åt listan slumpmässigt.
• ArrayList kan inte användas för omslagsklass för sådana fall.
• ArrayList i Java kan ses som en vektor i C++ .
• ArrayList är inte synkroniserad. Dess motsvarande synkroniserade klass i Java är Vektor .

Låt oss förstå Java ArrayList på djupet . Titta på bilden nedan:

I illustrationen ovan, Abstrakt lista , CopyOnWriteArrayList , och AbstractSequential List är klasserna som implementerar listgränssnittet. En separat funktionalitet är implementerad i var och en av de nämnda klasserna. Dom är:

1. Abstrakt lista: Denna klass används för att implementera en oförändrbar lista, för vilken man bara behöver utöka denna AbstractList Class och implementera endast skaffa sig() och den storlek() metoder.
2. CopyOnWriteArrayList: Denna klass implementerar listgränssnittet. Det är en förbättrad version av ArrayList där alla ändringar (lägg till, ställ in, ta bort, etc.) implementeras genom att göra en ny kopia av listan.
3. AbstractSequential List: Denna klass implementerar Samlingsgränssnitt och klassen AbstractCollection. Denna klass används för att implementera en oförändrbar lista, för vilken man bara behöver utöka denna AbstractList Class och implementera endast skaffa sig() och den storlek() metoder.

Konstruktörer i ArrayList i Java

För att skapa en ArrayList måste vi skapa ett objekt av klassen ArrayList. ArrayList-klassen består av olika konstruktörer som gör det möjligt att skapa arraylistan. Följande är de konstruktörer som finns tillgängliga i den här klassen:

1. ArrayList()

Denna konstruktor används för att bygga en tom arraylista. Om vi ​​vill skapa en tom ArrayList med namnet arr , då kan den skapas som:

ArrayList arr = new ArrayList();>

2. ArrayList (samling c)

Denna konstruktor används för att bygga en arraylista som initierats med elementen från samlingen c. Anta att vi vill skapa en ArrayList arr som innehåller elementen som finns i samlingen c, då kan den skapas som:

ArrayList arr = new ArrayList(c);>

3. ArrayList (int kapacitet)

Denna konstruktor används för att bygga en arraylista med den initiala kapaciteten specificerad. Anta att vi vill skapa en ArrayList med den ursprungliga storleken N, då kan den skapas som:

typ i java

ArrayList arr = new ArrayList(N);>

Java ArrayList-metoder

Notera: Du kan också skapa en generisk ArrayList:

// Skapar generiskt heltals ArrayList
ArrayList arrli = new ArrayList();

Några nyckelpunkter i ArrayList i Java

1. ArrayList är understruken datastruktur som kan ändra storlek på array eller Growable Array.
2. ArrayList-dubbletter är tillåtna.
3. Insättningsordningen bevaras.
4. Heterogena föremål är tillåtna.
5. Nollinsättning är möjlig.

Låt oss se hur man utför några grundläggande operationer på ArrayList som listas som vi kommer att diskutera vidare tillsammans med implementering av varje operation.

• Lägger till element till List/ Lägg till element
• Ändra element/ Ställ in element
• Ta bort element/Ta bort element
• Itererande element
• få element
• lägg till element mellan två tal
• Sortering av element
• ArrayList storlek

Operationer som utförs i ArrayList

1. Lägga till element

För att lägga till ett element till en ArrayList kan vi använda add() metod . Denna metod är överbelastad för att utföra flera operationer baserat på olika parametrar. De är följande:

• add(Object): Denna metod används för att lägga till ett element i slutet av ArrayList.
• add(int index, Object): Denna metod används för att lägga till ett element vid ett specifikt index i ArrayList.

Nedan är implementeringen av ovanstående tillvägagångssätt:

// Java Program to Add elements to An ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Array of string type  ArrayListal = new ArrayList();  // Lägga till element till ArrayList // Anpassade ingångar al.add('Geeks');  al.add('Nördar');  // Här nämner vi indexet // där det ska läggas till al.add(1, 'För');  // Skriver ut alla element i en ArrayList System.out.println(al);  } }>

[Geeks, For, Geeks]>

2. Ändra element

Efter att ha lagt till elementen, om vi vill ändra elementet, kan det göras med hjälp av uppsättning() metod. Eftersom en ArrayList är indexerad, refereras det element som vi vill ändra till av elementets index. Därför tar denna metod ett index och det uppdaterade elementet som måste infogas vid det indexet.

Nedan är implementeringen av ovanstående tillvägagångssätt:

// Java Program to Change elements in ArrayList // Importing all utility classes import java.util.*; // main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist object of string type  ArrayListal = new ArrayList();  // Lägga till element till Arraylist // Anpassade inmatningselement al.add('Geeks');  al.add('Nördar');  // Adding specificerar indexet som ska läggas till al.add(1, 'Geeks');  // Skriva ut Arraylist-elementen System.out.println('Initial ArrayList ' + al);  // Inställningselement vid 1:a index al.set(1, 'För');  // Skriver ut den uppdaterade Arraylistan System.out.println('Uppdaterad ArrayList ' + al);  } }>

Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>

3. Ta bort element

För att ta bort ett element från en ArrayList kan vi använda remove() metod . Denna metod är överbelastad för att utföra flera operationer baserat på olika parametrar. De är följande:

• remove(Object): Denna metod används för att helt enkelt ta bort ett objekt från ArrayList. Om det finns flera sådana objekt tas den första förekomsten av objektet bort.
• remove(int index): Eftersom en ArrayList är indexerad tar denna metod ett heltalsvärde som helt enkelt tar bort elementet som finns i det specifika indexet i ArrayList. Efter att ha tagit bort elementet flyttas alla element till vänster för att fylla utrymmet och objektens index uppdateras.

Exempel:

bash sova

// Java program to Remove Elements in ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an object of arraylist class  ArrayListal = new ArrayList();  // Lägga till element till ArrayList // Custom addition al.add('Geeks');  al.add('Nördar');  // Lägger till element vid specifikt index al.add(1, 'För');  // Skriver ut alla element i ArrayList System.out.println('Initial ArrayList ' + al);  // Ta bort element från ovan ArrayList al.remove(1);  // Skriver ut de uppdaterade Arraylist-elementen System.out.println('Efter borttagningen av index ' + al);  // Ta bort detta ordelement i ArrayList al.remove('Geeks');  // Skriver nu ut uppdaterad ArrayList System.out.println('Efter borttagningen av objekt ' + al);  } }>

Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>

4. Itererar ArrayList

Det finns flera sätt att iterera genom ArrayList. De mest kända sätten är att använda de grundläggande för slinga i kombination med en get() metoden för att få elementet vid ett specifikt index och avancerat för en slinga .

Exempel

// Java program to Iterate the elements // in an ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist of string type  ArrayListal = new ArrayList();  // Lägga till element i ArrayList // med standardmetoden add() al.add('Geeks');  al.add('Nördar');  al.add(1, 'För');  // Använda Get-metoden och // för loop för (int i = 0; i< al.size(); i++) {  System.out.print(al.get(i) + ' ');  }  System.out.println();  // Using the for each loop  for (String str : al)  System.out.print(str + ' ');  } }>

Geeks For Geeks Geeks For Geeks>

5. Skaffa element

// Java program to get the elemens in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main (String[] args) {  ArrayList list = new ArrayList();  // add the number list.add(9);  list.add(5);  list.add(6);  System.out.println(lista);  // get method Heltal n= list.get(1);  System.out.println('at indext 1 nummer är:'+n);  } }>

[9, 5, 6] at indext 1 number is:5>

6. Lägg till element mellan två siffror

// Java program to add the elements  // between two numbers in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList list = new ArrayList();  list.add(1);  list.add(2);  list.add(4);  System.out.println(lista);  // infoga saknat element 3 list.add(2, 3);  System.out.println(lista);  } }>

[1, 2, 4] [1, 2, 3, 4]>

7. Sortera ArrayList

// Java Program for ArrayList Sorting import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList list = new ArrayList();  list.add(2);  list.add(4);  list.add(3);  list.add(1);  System.out.println('Innan sorteringslista:');  System.out.println(lista);  Collections.sort(lista);  System.out.println('efter sorteringslista:');  System.out.println(lista);  } }>

Before sorting list: [2, 4, 3, 1] after sorting list: [1, 2, 3, 4]>

8. Storlek på element

// Java program to find the size  // of elements of an ArrayList import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList list = new ArrayList();  list.add(1);  list.add(2);  list.add(3);  list.add(4);  int b = list.size();  System.out.println('Storleken är :' + b);  } }>

The size is :4>

Java ArrayLists komplexitet

ArrayList i Java är en klass i Java Collections-ramverket som implementerar List-gränssnittet. Här är fördelarna och nackdelarna med att använda ArrayList i Java.

Fördelar med Java ArrayList

1. Dynamisk storlek: ArrayList kan dynamiskt växa och krympa i storlek, vilket gör det enkelt att lägga till eller ta bort element efter behov.
2. Lätt att använda: ArrayList är enkel att använda, vilket gör det till ett populärt val för många Java-utvecklare.
3. Snabb åtkomst: ArrayList ger snabb åtkomst till element, eftersom den är implementerad som en array under huven.
4. Ordnad samling: ArrayList bevarar ordningen på elementen, så att du kan komma åt elementen i den ordning de lades till.
5. Stöder nollvärden: ArrayList kan lagra nollvärden, vilket gör det användbart i fall där frånvaron av ett värde måste representeras.

Nackdelar med Java ArrayList

1. Långsammare än arrayer: ArrayList är långsammare än arrayer för vissa operationer, som att infoga element i mitten av listan.
2. Ökad minnesanvändning: ArrayList kräver mer minne än arrayer, eftersom den behöver behålla sin dynamiska storlek och hantera storleksändring.
3. Inte trådsäker: ArrayList är inte trådsäker, vilket innebär att flera trådar kan komma åt och ändra listan samtidigt, vilket leder till potentiella tävlingsförhållanden och datakorruption.
4. Prestandaförsämring: ArrayLists prestanda kan försämras när antalet element i listan ökar, särskilt för operationer som att söka efter element eller infoga element i mitten av listan.

Slutsats

Punkter att komma ihåg från den här artikeln nämns nedan:

• ArrayList är en del av samlingsramverket. Den ärver klassen AbstractList och implementerar List-gränssnittet.
• ArrayList är implementeringen av en dynamisk array.
• ArrayList kan initieras med hjälp av olika konstruktortyper som utan parametrar, skicka samling som en parameter och skicka heltal som en parameter.
• Åtgärder kan utföras i ArrayList enligt följande Lägga till, ta bort, iterera och sortera.

Vanliga frågor om ArrayList

Vad är en ArrayList i Java?

ArrayList i Java är en del av samlingsramverket. Den används för att lagra element och storleken kan ändras.

Hur lagras data i ArrayList?

ArrayList kan lagra data tills ArrayList-storleken är full, efter det fördubblas storleken på ArrayList om vi vill lagra fler element.

Tillåter ArrayList dubbletter?

Ja, ArrayList tillåter att dubbletter av värden lagras.