Java ArrayList er en del af Java samlingsramme og det er en klasse af java.util-pakken. Det giver os dynamiske arrays i Java. Det kan dog være langsommere end standard arrays, men det kan være nyttigt i programmer, hvor der er behov for masser af manipulation i arrayet. Denne klasse findes i java.util pakke. Det vigtigste fordel ved ArrayList i Java er, at hvis vi erklærer et array, skal vi nævne størrelsen, men i ArrayList er det ikke nødvendigt at nævne størrelsen på ArrayList. Hvis du vil nævne størrelsen, så kan du gøre det.

Indholdsfortegnelse

• Hvad er ArrayList i Java?
• Eksempel på Java ArrayList
• Vigtige funktioner i ArrayList i Java
• Konstruktører i ArrayList
• ArrayList i Java-metoder
• Operationer udført i ArrayList
• Kompleksiteten af ​​Java ArrayList
• Fordele ved Java ArrayList
• Ulemper ved Java ArrayList
• Konklusion
• Ofte stillede spørgsmål om ArrayList

Hvad er ArrayList i Java?

ArrayList er en Java-klasse implementeret ved hjælp af List-grænsefladen. Java ArrayList, som navnet antyder, giver funktionaliteten af ​​et dynamisk array, hvor størrelsen ikke er fastsat som et array. Som en del af samlingsrammen har den også mange funktioner, der ikke er tilgængelige med arrays.

Illustration:

Lad os se på ArrayList med integer-objekttypen gemt i den med et billede.

Eksempel på Java ArrayList

Eksempel 1: Den følgende implementering viser, hvordan man opretter og bruger en ArrayList med en omtale af dens størrelse.

hvordan opgraderer jeg java

// 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);  // Erklæring af ArrayList ArrayList arr2 = ny ArrayList ();  // Udskrivning af ArrayList System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  // Tilføjelse af nye elementer i // slutningen af ​​listen for (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]>

Forklaring af ovenstående program:

ArrayList er et dynamisk array, og vi behøver ikke at angive størrelsen, mens vi opretter det, størrelsen af ​​arrayet øges automatisk, når vi dynamisk tilføjer og fjerner elementer. Selvom den faktiske biblioteksimplementering kan være mere kompleks, er følgende en meget grundlæggende idé, der forklarer, hvordan arrayet fungerer, når arrayet bliver fuldt, og hvis vi forsøger at tilføje et element:

• Opretter en større hukommelse på heap-hukommelse (for eksempel hukommelse i dobbelt størrelse).
• Kopierer de aktuelle hukommelseselementer til den nye hukommelse.
• Det nye element er tilføjet nu, da der er større hukommelse tilgængelig nu.
• Slet den gamle hukommelse.

Vigtige funktioner i ArrayList i Java

• ArrayList arver Abstrakt liste klasse og implementerer Listegrænseflade .
• ArrayList initialiseres efter størrelse. Størrelsen øges dog automatisk, hvis samlingen vokser eller krymper, hvis den genstande fjernes fra samlingen.
• Java ArrayList giver os mulighed for tilfældigt at få adgang til listen.
• ArrayList kan ikke bruges til indpakningsklasse for sådanne tilfælde.
• ArrayList i Java kan ses som en vektor i C++ .
• ArrayList er ikke synkroniseret. Dens tilsvarende synkroniserede klasse i Java er Vektor .

Lad os forstå Java ArrayList i dybden . Se på nedenstående billede:

I ovenstående illustration, Abstrakt liste , CopyOnWriteArrayList , og Abstrakt sekventiel liste er de klasser, der implementerer listegrænsefladen. En separat funktionalitet er implementeret i hver af de nævnte klasser. De er:

1. Abstrakt liste: Denne klasse bruges til at implementere en ikke-modificerbar liste, for hvilken man kun behøver at udvide denne AbstractList-klasse og kun implementere få() og størrelse() metoder.
2. CopyOnWriteArrayList: Denne klasse implementerer listegrænsefladen. Det er en forbedret version af ArrayList hvor alle ændringerne (tilføj, sæt, fjern osv.) implementeres ved at lave en ny kopi af listen.
3. Abstrakt sekventiel liste: Denne klasse implementerer Samling grænseflade og klassen AbstractCollection. Denne klasse bruges til at implementere en ikke-modificerbar liste, for hvilken man kun behøver at udvide denne AbstractList-klasse og kun implementere få() og størrelse() metoder.

Konstruktører i ArrayList i Java

For at oprette en ArrayList skal vi oprette et objekt af ArrayList-klassen. ArrayList-klassen består af forskellige konstruktører som muliggør oprettelse af arraylisten. Følgende er konstruktørerne tilgængelige i denne klasse:

1. ArrayList()

Denne konstruktør bruges til at bygge en tom matrixliste. Hvis vi ønsker at oprette en tom ArrayList med navnet arr , så kan det oprettes som:

ArrayList arr = new ArrayList();>

2. ArrayList (Samling c)

Denne konstruktør bruges til at bygge en array-liste initialiseret med elementerne fra samlingen c. Antag, at vi ønsker at oprette en ArrayList arr, som indeholder elementerne i samlingen c, så kan den oprettes som:

ArrayList arr = new ArrayList(c);>

3. ArrayList (int kapacitet)

Denne konstruktør bruges til at bygge en array-liste med den oprindelige kapacitet angivet. Antag, at vi ønsker at oprette en ArrayList, hvor den oprindelige størrelse er N, så kan den oprettes som:

ArrayList arr = new ArrayList(N);>

Java ArrayList metoder

Bemærk: Du kan også oprette en generisk ArrayList:

1. ordens logik

// Oprettelse af generisk heltal ArrayList
ArrayList arrli = new ArrayList();

Nogle nøglepunkter i ArrayList i Java

1. ArrayList er understreget datastruktur Array, der kan ændres størrelse eller Growable Array.
2. ArrayList-duplikater er tilladt.
3. Indsættelsesrækkefølgen er bevaret.
4. Heterogene genstande er tilladt.
5. Nul indsættelse er mulig.

Lad os se, hvordan du udfører nogle grundlæggende operationer på ArrayList som anført, som vi vil diskutere yderligere sammen med implementering af hver operation.

• Tilføjelse af element til List/ Tilføj element
• Ændring af elementer/ Sæt element
• Fjernelse af elementer/Slet element
• Itererende elementer
• få elementer
• tilføje elementer mellem to tal
• Sortering af elementer
• ArrayList størrelse

Operationer udført i ArrayList

1. Tilføjelse af elementer

For at tilføje et element til en ArrayList kan vi bruge add() metode . Denne metode er overbelastet til at udføre flere operationer baseret på forskellige parametre. De er som følger:

• add(Object): Denne metode bruges til at tilføje et element i slutningen af ​​ArrayList.
• add(int index, Object): Denne metode bruges til at tilføje et element til et specifikt indeks i ArrayList.

Nedenfor er implementeringen af ​​ovenstående tilgang:

// 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 = ny ArrayList();  // Tilføjelse af elementer til ArrayList // Brugerdefinerede input al.add('Nørder');  al.add('Nørder');  // Her nævner vi indekset // hvor det skal tilføjes al.add(1, 'For');  // Udskrivning af alle elementer i et ArrayList System.out.println(al);  } }>

[Geeks, For, Geeks]>

2. Ændring af elementer

Efter tilføjelse af elementerne, hvis vi ønsker at ændre elementet, kan det gøres ved hjælp af sæt() metode. Da en ArrayList er indekseret, refereres det element, som vi ønsker at ændre, af elementets indeks. Derfor tager denne metode et indeks og det opdaterede element, som skal indsættes i det indeks.

Nedenfor er implementeringen af ​​ovenstående tilgang:

// 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 = ny ArrayList();  // Tilføjelse af elementer til Arraylist // Brugerdefinerede input-elementer al.add('Nørder');  al.add('Nørder');  // Tilføjelse angiver det indeks, der skal tilføjes al.add(1, 'Nørder');  // Udskrivning af Arraylist-elementerne System.out.println('Initial ArrayList ' + al);  // Indstillingselement ved 1. indeks al.set(1, 'For');  // Udskrivning af den opdaterede Arraylist System.out.println('Opdateret ArrayList ' + al);  } }>

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

3. Fjernelse af elementer

For at fjerne et element fra en ArrayList kan vi bruge remove() metode . Denne metode er overbelastet til at udføre flere operationer baseret på forskellige parametre. De er som følger:

• fjern (objekt): Denne metode bruges til blot at fjerne et objekt fra ArrayList. Hvis der er flere sådanne objekter, fjernes den første forekomst af objektet.
• remove(int index): Da en ArrayList er indekseret, tager denne metode en heltalsværdi, som blot fjerner det element, der er til stede ved det specifikke indeks i ArrayList. Efter fjernelse af elementet flyttes alle elementer til venstre for at udfylde rummet, og objekternes indekser opdateres.

Eksempel:

// 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 = ny ArrayList();  // Tilføjelse af elementer til ArrayList // Brugerdefineret tilføjelse al.add('Nørder');  al.add('Nørder');  // Tilføjelse af element ved specifikt indeks al.add(1, 'For');  // Udskrivning af alle elementer af ArrayList System.out.println('Initial ArrayList ' + al);  // Fjerner element fra oven ArrayList al.remove(1);  // Udskrivning af de opdaterede Arraylist-elementer System.out.println('Efter indeksfjernelsen ' + al);  // Fjernelse af dette ordelement i ArrayList al.remove('Geeks');  // Udskriver nu opdateret ArrayList System.out.println('Efter objektfjernelsen ' + al);  } }>

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

4. Gentagelse af ArrayList

Der er flere måder at gentage gennem ArrayList. De mest berømte måder er ved at bruge det grundlæggende for sløjfe i kombination med en get() metode for at få elementet på et bestemt indeks og avanceret for en løkke .

Eksempel

// 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 = ny ArrayList();  // Tilføjelse af elementer til ArrayList // ved hjælp af standard add() metode al.add('Nørder');  al.add('Nørder');  al.add(1, 'For');  // Brug af Get-metoden og // for loop 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. Hent elementer

// 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();  // tilføj nummerlisten.add(9);  list.add(5);  list.add(6);  System.out.println(liste);  // få metode Heltal n= liste.get(1);  System.out.println('at indext 1 nummer er:'+n);  } }>

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

6. Tilføj elementer mellem to tal

// 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(liste);  // indsæt manglende element 3 list.add(2, 3);  System.out.println(liste);  } }>

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

7. Sortér 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('Før sorteringsliste:');  System.out.println(liste);  Collections.sort(liste);  System.out.println('efter sorteringsliste:');  System.out.println(liste);  } }>

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

8. Størrelse af elementer

// 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 = liste.størrelse();  System.out.println('Størrelsen er :' + b);  } }>

The size is :4>

Kompleksiteten af ​​Java ArrayList

ArrayList i Java er en klasse i Java Collections-rammeværket, der implementerer List-grænsefladen. Her er fordele og ulemper ved at bruge ArrayList i Java.

Fordele ved Java ArrayList

1. Dynamisk størrelse: ArrayList kan dynamisk vokse og krympe i størrelse, hvilket gør det nemt at tilføje eller fjerne elementer efter behov.
2. Nem at bruge: ArrayList er enkel at bruge, hvilket gør det til et populært valg for mange Java-udviklere.
3. Hurtig adgang: ArrayList giver hurtig adgang til elementer, da den er implementeret som et array under hætten.
4. Ordnet samling: ArrayList bevarer rækkefølgen af ​​elementer, så du kan få adgang til elementer i den rækkefølge, de blev tilføjet.
5. Understøtter null-værdier: ArrayList kan gemme null-værdier, hvilket gør det nyttigt i tilfælde, hvor fraværet af en værdi skal repræsenteres.

Ulemper ved Java ArrayList

1. Langsommere end arrays: ArrayList er langsommere end arrays for visse operationer, såsom at indsætte elementer i midten af ​​listen.
2. Øget hukommelsesbrug: ArrayList kræver mere hukommelse end arrays, da den skal bevare sin dynamiske størrelse og håndtere størrelsesændring.
3. Ikke trådsikker: ArrayList er ikke trådsikker, hvilket betyder, at flere tråde kan få adgang til og ændre listen samtidigt, hvilket fører til potentielle raceforhold og datakorruption.
4. Ydeevneforringelse: ArrayLists ydeevne kan forringes, efterhånden som antallet af elementer på listen stiger, især for operationer såsom at søge efter elementer eller indsætte elementer i midten af ​​listen.

Konklusion

Punkter, der skal huskes fra denne artikel, er nævnt nedenfor:

• ArrayList er en del af Collections framework. Det arver AbstractList-klassen og implementerer List-grænsefladen.
• ArrayList er implementeringen af ​​et dynamisk array.
• ArrayList kan initialiseres ved at bruge forskellige konstruktørtyper som uden parametre, at overføre samling som en parameter og at sende heltal som en parameter.
• Operationer kan udføres i ArrayList som følger Tilføjelse, fjernelse, iteration og sortering.

Ofte stillede spørgsmål om ArrayList

Hvad er en ArrayList i Java?

ArrayList i Java er en del af samlingsrammen. Det bruges til at gemme elementer, og størrelsen kan ændres.

Hvordan opbevares data i ArrayList?

ArrayList kan gemme data, indtil ArrayList-størrelsen er fuld, derefter fordobles størrelsen af ​​ArrayList, hvis vi ønsker at gemme flere elementer.

Tillader ArrayList dubletter?

Ja, ArrayList tillader, at duplikerede værdier gemmes.