Java ArrayList maakt deel uit van Java collecties raamwerk en het is een klasse van het java.util-pakket. Het biedt ons dynamische arrays in Java. Hoewel het langzamer kan zijn dan standaardarrays, kan het nuttig zijn in programma's waarbij veel manipulatie in de array nodig is. Deze klasse is te vinden in java.util pakket. De belangrijkste voordeel van ArrayList in Java is dat als we een array declareren, we de grootte moeten vermelden, maar in ArrayList is het niet nodig om de grootte van ArrayList te vermelden. Als je de maat wilt vermelden, dan kan dat.

Inhoudsopgave

• Wat is ArrayList in Java?
• Java ArrayList-voorbeeld
• Belangrijke kenmerken van ArrayList in Java
• Constructeurs in ArrayList
• ArrayList in Java-methoden
• Bewerkingen uitgevoerd in ArrayList
• Complexiteit van Java ArrayList
• Voordelen van Java ArrayList
• Nadelen van Java ArrayList
• Conclusie
• Veelgestelde vragen over ArrayList

Wat is ArrayList in Java?

ArrayList is een Java-klasse die is geïmplementeerd met behulp van de List-interface. Java ArrayList biedt, zoals de naam al doet vermoeden, de functionaliteit van een dynamische array waarbij de grootte niet vastligt als een array. Als onderdeel van het Collections-framework heeft het ook veel functies die niet beschikbaar zijn bij arrays.

Illustratie:

Laten we de ArrayList controleren met het Integer Object-type erin opgeslagen met een afbeelding.

Java ArrayList-voorbeeld

Voorbeeld 1: De volgende implementatie laat zien hoe u een ArrayList kunt maken en gebruiken, met vermelding van de grootte ervan.

// 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 = nieuwe ArrayList (N);  // De ArrayList ArrayList declareren arr2 = nieuwe ArrayList ();  // De ArrayList System.out.println afdrukken ('Array 1:' + arr1);  Systeem.out.println('Array 2:' + arr2);  // Nieuwe elementen toevoegen aan // het einde van de lijst voor (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]>

Uitleg van het bovenstaande programma:

ArrayList is een dynamische array en we hoeven de grootte niet op te geven tijdens het maken ervan; de grootte van de array neemt automatisch toe wanneer we dynamisch items toevoegen en verwijderen. Hoewel de daadwerkelijke bibliotheekimplementatie complexer kan zijn, is het volgende een heel basisidee waarin de werking van de array wordt uitgelegd wanneer de array vol raakt en als we proberen een item toe te voegen:

bellen sorteren in algoritme

• Creëert een groter geheugen op heap-geheugen (bijvoorbeeld geheugen van dubbele grootte).
• Kopieert de huidige geheugenelementen naar het nieuwe geheugen.
• Het nieuwe item is nu toegevoegd omdat er nu meer geheugen beschikbaar is.
• Verwijder het oude geheugen.

Belangrijke kenmerken van ArrayList in Java

• ArrayList erft SamenvattingLijst klasse en implementeert de Lijstinterface .
• ArrayList wordt geïnitialiseerd op grootte. De omvang wordt echter automatisch vergroot als de collectie groeit of krimpt als de collectie groter wordt voorwerpen worden uit de collectie verwijderd.
• Met Java ArrayList kunnen we willekeurig toegang krijgen tot de lijst.
• ArrayList kan niet worden gebruikt voor wikkelklasse voor dergelijke gevallen.
• ArrayList in Java kan worden gezien als een vectoren in C++ .
• ArrayList is niet gesynchroniseerd. De equivalente gesynchroniseerde klasse in Java is Vector .

Laten we het begrijpen Java ArrayList diepgaand . Kijk naar de onderstaande afbeelding:

In de bovenstaande illustratie, SamenvattingLijst , CopyOnWriteArrayList , En SamenvattingSequentiëleLijst zijn de klassen die de lijstinterface implementeren. In elk van de genoemde klassen is een aparte functionaliteit geïmplementeerd. Zij zijn:

sorteer arraylijst java

1. SamenvattingLijst: Deze klasse wordt gebruikt om een ​​niet-wijzigbare lijst te implementeren, waarvoor men alleen deze AbstractList-klasse hoeft uit te breiden en alleen de krijgen() en de maat() methoden.
2. CopyOnWriteArrayLijst: Deze klasse implementeert de lijstinterface. Het is een verbeterde versie van ArrayLijst waarin alle wijzigingen (toevoegen, instellen, verwijderen, enz.) worden geïmplementeerd door een nieuwe kopie van de lijst te maken.
3. SamenvattingSequentiëleLijst: Deze klasse implementeert de Verzamelinterface en de klasse AbstractCollection. Deze klasse wordt gebruikt om een ​​niet-wijzigbare lijst te implementeren, waarvoor men alleen deze AbstractList-klasse hoeft uit te breiden en alleen de krijgen() en de maat() methoden.

Constructors in ArrayList in Java

Om een ​​ArrayList te maken, moeten we een object van de klasse ArrayList maken. De klasse ArrayList bestaat uit verschillende constructeurs waarmee de mogelijke creatie van de arraylijst mogelijk is. De volgende constructors zijn beschikbaar in deze klasse:

1. ArrayLijst()

Deze constructor wordt gebruikt om een ​​lege arraylijst samen te stellen. Als we een lege ArrayList willen maken met de naam arr , dan kan het worden gemaakt als:

ArrayList arr = new ArrayList();>

2. ArrayList(verzameling c)

Deze constructor wordt gebruikt om een ​​arraylijst samen te stellen die is geïnitialiseerd met de elementen uit de verzameling c. Stel dat we een ArrayList arr willen maken die de elementen bevat die aanwezig zijn in de verzameling c, dan kan deze worden gemaakt als:

ArrayList arr = new ArrayList(c);>

3. ArrayList(int-capaciteit)

Deze constructor wordt gebruikt om een ​​arraylijst samen te stellen waarbij de initiële capaciteit wordt gespecificeerd. Stel dat we een ArrayList willen maken met de initiële grootte N, dan kan deze worden gemaakt als:

ArrayList arr = new ArrayList(N);>

Java ArrayList-methoden

Opmerking: U kunt ook een generieke ArrayList maken:

// Generieke integer ArrayList maken
ArrayList arrli = nieuwe ArrayList();

Enkele kernpunten van ArrayList in Java

1. ArrayList is een onderstreepte gegevensstructuur, aanpasbare array of een groeiende array.
2. ArrayList-duplicaten zijn toegestaan.
3. De invoegvolgorde blijft behouden.
4. Heterogene objecten zijn toegestaan.
5. Null-invoeging is mogelijk.

Laten we eens kijken hoe we enkele basisbewerkingen op de ArrayList kunnen uitvoeren, zoals vermeld, die we verder gaan bespreken naast het implementeren van elke bewerking.

• Element toevoegen aan lijst/element toevoegen
• Elementen wijzigen/element instellen
• Elementen verwijderen/element verwijderen
• Itererende elementen
• elementen krijgen
• voeg elementen toe tussen twee getallen
• Elementen sorteren
• ArrayList-grootte

Bewerkingen uitgevoerd in ArrayList

1. Elementen toevoegen

Om een ​​element aan een ArrayList toe te voegen, kunnen we de add() methode . Deze methode is overbelast om meerdere bewerkingen uit te voeren op basis van verschillende parameters. Ze zijn als volgt:

• add(Object): Deze methode wordt gebruikt om een ​​element aan het einde van de ArrayList toe te voegen.
• add(int index, Object): Deze methode wordt gebruikt om een ​​element toe te voegen aan een specifieke index in de ArrayList.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

// 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 = nieuwe ArrayList();  // Elementen toevoegen aan ArrayList // Aangepaste invoer al.add('Geeks');  al.add('Geeks');  // Hier vermelden we de index // waaraan deze moet worden toegevoegd al.add(1, 'For');  // Alle elementen in een ArrayList System.out.println(al) afdrukken;  } }>

[Geeks, For, Geeks]>

2. Elementen veranderen

Als we na het toevoegen van de elementen het element willen wijzigen, kan dit worden gedaan met behulp van de set() methode. Omdat een ArrayList is geïndexeerd, wordt naar het element dat we willen wijzigen verwezen door de index van het element. Daarom gebruikt deze methode een index en het bijgewerkte element dat in die index moet worden ingevoegd.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

binaire zoekboom]

// 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 = nieuwe ArrayList();  // Elementen toevoegen aan Arraylist // Aangepaste invoerelementen al.add('Geeks');  al.add('Geeks');  // Toevoeging van de toe te voegen index al.add(1, 'Geeks');  // De Arraylist-elementen afdrukken System.out.println('Initial ArrayList ' + al);  // Instellingselement op de 1e index al.set(1, 'For');  // De bijgewerkte Arraylist System.out.println afdrukken ('Updated ArrayList ' + al);  } }>

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

3. Elementen verwijderen

Om een ​​element uit een ArrayList te verwijderen, kunnen we de verwijder() methode . Deze methode is overbelast om meerdere bewerkingen uit te voeren op basis van verschillende parameters. Ze zijn als volgt:

• verwijder(Object): Deze methode wordt gebruikt om eenvoudig een object uit de ArrayList te verwijderen. Als er meerdere van dergelijke objecten zijn, wordt het eerste exemplaar van het object verwijderd.
• verwijder(int index): Omdat een ArrayList wordt geïndexeerd, neemt deze methode een geheel getal, waardoor eenvoudigweg het element wordt verwijderd dat aanwezig is in die specifieke index in de ArrayList. Na het verwijderen van het element worden alle elementen naar links verplaatst om de ruimte te vullen en worden de indexen van de objecten bijgewerkt.

Voorbeeld:

// 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 = nieuwe ArrayList();  // Elementen toevoegen aan ArrayList // Aangepaste toevoeging al.add('Geeks');  al.add('Geeks');  // Element toevoegen aan specifieke index al.add(1, 'For');  // Alle elementen van ArrayList System.out.println afdrukken ('Initial ArrayList ' + al);  // Element van bovenaf verwijderen ArrayList al.remove(1);  // De bijgewerkte Arraylist-elementen afdrukken System.out.println('After the Index Removal' + al);  // Dit woordelement verwijderen in ArrayList al.remove('Geeks');  // Nu bezig met het afdrukken van bijgewerkte ArrayList System.out.println('Na het verwijderen van het object' + al);  } }>

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

4. De ArrayList herhalen

Er zijn meerdere manieren om de ArrayList te doorlopen. De bekendste manieren zijn door gebruik te maken van de basis for loop in combinatie met een get() methode om het element op een specifieke index te krijgen en de ging vooruit voor een lus .

Voorbeeld

// 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 = nieuwe ArrayList();  // Elementen toevoegen aan ArrayList // met behulp van de standaard add()-methode al.add('Geeks');  al.add('Geeks');  al.add(1, 'Voor');  // Met behulp van de Get-methode en de // for-lus for (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. Verzamel elementen

// Java program to get the elemens in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main (String[] args) {  ArrayList lijst = nieuwe ArrayList();  // voeg de nummerlijst toe.add(9);  lijst.add(5);  lijst.add(6);  Systeem.out.println(lijst);  // get-methode Integer n= list.get(1);  System.out.println('bij indext 1 nummer is:'+n);  } }>

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

6. Voeg elementen toe tussen twee getallen

// 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 lijst = nieuwe ArrayList();  lijst.add(1);  lijst.add(2);  lijst.add(4);  Systeem.out.println(lijst);  // voeg ontbrekend element in 3 list.add(2, 3);  Systeem.out.println(lijst);  } }>

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

7. ArrayList sorteren

// Java Program for ArrayList Sorting import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList lijst = nieuwe ArrayList();  lijst.add(2);  lijst.add(4);  lijst.add(3);  lijst.add(1);  System.out.println('Voordat de lijst wordt gesorteerd:');  Systeem.out.println(lijst);  Collecties.sort(lijst);  System.out.println('na sorteerlijst:');  Systeem.out.println(lijst);  } }>

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

8. Grootte van elementen

// 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 lijst = nieuwe ArrayList();  lijst.add(1);  lijst.add(2);  lijst.add(3);  lijst.add(4);  int b = lijst.grootte();  System.out.println('De grootte is:' + b);  } }>

The size is :4>

Complexiteit van Java ArrayList

ArrayList in Java is een klasse in het Java Collections-framework dat de List-interface implementeert. Hier zijn de voor- en nadelen van het gebruik van ArrayList in Java.

Voordelen van Java ArrayList

1. Dynamische grootte: ArrayList kan dynamisch groter en kleiner worden, waardoor het gemakkelijk wordt om elementen toe te voegen of te verwijderen als dat nodig is.
2. Gemakkelijk te gebruiken: ArrayList is eenvoudig te gebruiken, waardoor het een populaire keuze is voor veel Java-ontwikkelaars.
3. Snelle toegang: ArrayList biedt snelle toegang tot elementen, omdat het is geïmplementeerd als een array onder de motorkap.
4. Geordende verzameling: ArrayList behoudt de volgorde van de elementen, zodat u toegang krijgt tot elementen in de volgorde waarin ze zijn toegevoegd.
5. Ondersteunt nulwaarden: ArrayList kan nulwaarden opslaan, wat handig is in gevallen waarin de afwezigheid van een waarde moet worden weergegeven.

Nadelen van Java ArrayList

1. Langzamer dan arrays: ArrayList is langzamer dan arrays voor bepaalde bewerkingen, zoals het invoegen van elementen in het midden van de lijst.
2. Verhoogd geheugengebruik: ArrayList vereist meer geheugen dan arrays, omdat het zijn dynamische grootte moet behouden en het wijzigen van de grootte moet verwerken.
3. Niet thread-safe: ArrayList is niet thread-safe, wat betekent dat meerdere threads tegelijkertijd toegang kunnen krijgen tot de lijst en deze kunnen wijzigen, wat kan leiden tot mogelijke racecondities en gegevenscorruptie.
4. Prestatievermindering: de prestaties van ArrayList kunnen afnemen naarmate het aantal elementen in de lijst toeneemt, vooral bij bewerkingen zoals het zoeken naar elementen of het invoegen van elementen in het midden van de lijst.

Conclusie

Punten die u uit dit artikel moet onthouden, worden hieronder vermeld:

• ArrayList is het onderdeel van het Collections-framework. Het erft de klasse AbstractList en implementeert de List-interface.
• ArrayList is de implementatie van een dynamische array.
• ArrayList kan worden geïnitialiseerd met behulp van verschillende constructortypen, zoals zonder parameters, het doorgeven van de verzameling als parameter en het doorgeven van geheel getal als parameter.
• Bewerkingen kunnen als volgt in ArrayList worden uitgevoerd: Toevoegen, verwijderen, itereren en sorteren.

Veelgestelde vragen over ArrayList

Wat is een ArrayList in Java?

ArrayList in Java is een onderdeel van het Collections-framework. Het wordt gebruikt om elementen op te slaan en de grootte is aanpasbaar.

Hoe worden gegevens opgeslagen in ArrayList?

ArrayList kan gegevens opslaan totdat de ArrayList-grootte vol is, daarna wordt de grootte van ArrayList verdubbeld als we nog meer elementen willen opslaan.

Staat ArrayList duplicaten toe?

Ja, met ArrayList kunnen dubbele waarden worden opgeslagen.