Java ArrayList er en del av Java samlingsramme og det er en klasse av java.util-pakken. Det gir oss dynamiske arrays i Java. Skjønt, det kan være tregere enn standard arrays, men kan være nyttig i programmer der mye manipulasjon i arrayen er nødvendig. Denne klassen finnes i java.util pakke. Hoved fordelen med ArrayList i Java er at hvis vi erklærer en matrise, må vi nevne størrelsen, men i ArrayList er det ikke nødvendig å nevne størrelsen på ArrayList. Hvis du vil nevne størrelsen, kan du gjøre det.

Innholdsfortegnelse

• Hva er ArrayList i Java?
• Eksempel på Java ArrayList
• Viktige funksjoner i ArrayList i Java
• Konstruktører i ArrayList
• ArrayList i Java-metoder
• Operasjoner utført i ArrayList
• Kompleksiteten til Java ArrayList
• Fordeler med Java ArrayList
• Ulemper med Java ArrayList
• Konklusjon
• Vanlige spørsmål om ArrayList

Hva er ArrayList i Java?

ArrayList er en Java-klasse implementert ved hjelp av List-grensesnittet. Java ArrayList, som navnet antyder, gir funksjonaliteten til en dynamisk matrise der størrelsen ikke er fast som en matrise. Som en del av rammeverket for samlinger har den også mange funksjoner som ikke er tilgjengelige med arrays.

Illustrasjon:

La oss sjekke ArrayList med integer-objekttypen lagret i den med et bilde.

Eksempel på Java ArrayList

Eksempel 1: Følgende implementering viser hvordan du oppretter og bruker en ArrayList med en omtale av størrelsen.

java arkitektur

// 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ærer ArrayList ArrayList arr2 = ny ArrayList ();  // Skrive ut ArrayList System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  // Legge til nye elementer på // slutten av 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 av programmet ovenfor:

ArrayList er en dynamisk matrise og vi trenger ikke å spesifisere størrelsen mens vi lager den, størrelsen på matrisen øker automatisk når vi dynamisk legger til og fjerner elementer. Selv om den faktiske bibliotekimplementeringen kan være mer kompleks, er følgende en veldig grunnleggende idé som forklarer hvordan matrisen fungerer når matrisen blir full og hvis vi prøver å legge til et element:

• Oppretter et større minne på heap-minne (for eksempel minne med dobbel størrelse).
• Kopierer gjeldende minneelementer til det nye minnet.
• Det nye elementet er lagt til nå ettersom det er større minne tilgjengelig nå.
• Slett det gamle minnet.

Viktige funksjoner i ArrayList i Java

• ArrayList arver Abstrakt liste klasse og implementerer Listegrensesnitt .
• ArrayList initialiseres etter størrelse. Imidlertid økes størrelsen automatisk hvis samlingen vokser eller krymper hvis den gjenstander fjernes fra samlingen.
• Java ArrayList lar oss få tilgang til listen tilfeldig.
• ArrayList kan ikke brukes til innpakningsklasse for slike tilfeller.
• ArrayList i Java kan sees på som en vektor i C++ .
• ArrayList er ikke synkronisert. Dens tilsvarende synkroniserte klasse i Java er Vektor .

La oss forstå Java ArrayList i dybden . Se på bildet nedenfor:

I illustrasjonen ovenfor, Abstrakt liste , CopyOnWriteArrayList , og Abstrakt sekvensliste er klassene som implementerer listegrensesnittet. En egen funksjonalitet er implementert i hver av de nevnte klassene. De er:

1. Abstrakt liste: Denne klassen brukes til å implementere en ikke-modifiserbar liste, for hvilken man bare trenger å utvide denne AbstractList-klassen og implementere bare få() og størrelse() metoder.
2. CopyOnWriteArrayList: Denne klassen implementerer listegrensesnittet. Det er en forbedret versjon av ArrayList der alle endringene (legg til, sett, fjern, etc.) implementeres ved å lage en ny kopi av listen.
3. Abstrakt sekvensliste: Denne klassen implementerer Samlingsgrensesnitt og AbstractCollection-klassen. Denne klassen brukes til å implementere en ikke-modifiserbar liste, for hvilken man bare trenger å utvide denne AbstractList-klassen og implementere bare få() og størrelse() metoder.

Konstruktører i ArrayList i Java

For å lage en ArrayList, må vi lage et objekt av ArrayList-klassen. ArrayList-klassen består av ulike konstruktører som muliggjør opprettelse av arraylisten. Følgende er konstruktørene som er tilgjengelige i denne klassen:

1. ArrayList()

Denne konstruktøren brukes til å bygge en tom matriseliste. Hvis vi ønsker å lage en tom ArrayList med navnet arr , da kan den opprettes som:

ArrayList arr = new ArrayList();>

2. ArrayList (samling c)

Denne konstruktøren brukes til å bygge en matriseliste initialisert med elementene fra samlingen c. Anta at vi ønsker å lage en ArrayList arr som inneholder elementene som er tilstede i samlingen c, så kan den opprettes som:

ArrayList arr = new ArrayList(c);>

3. ArrayList (int kapasitet)

Denne konstruktøren brukes til å bygge en matriseliste med den opprinnelige kapasiteten spesifisert. Anta at vi ønsker å lage en ArrayList med startstørrelsen N, så kan den opprettes som:

ArrayList arr = new ArrayList(N);>

Java ArrayList-metoder

Merk: Du kan også lage en generisk ArrayList:

null sjekker i java

// Opprette generisk heltall ArrayList
ArrayList arrli = new ArrayList();

Noen nøkkelpunkter i ArrayList i Java

1. ArrayList er understreket datastruktur Resizable Array eller Growable Array.
2. ArrayList-duplikater er tillatt.
3. Innsettingsrekkefølge er bevart.
4. Heterogene gjenstander er tillatt.
5. Nullinnsetting er mulig.

La oss se hvordan du utfører noen grunnleggende operasjoner på ArrayList som er oppført som vi skal diskutere videre ved siden av implementering av hver operasjon.

• Legger til element til List/ Legg til element
• Endre elementer/ Sett element
• Fjerne elementer/Slett element
• Itererende elementer
• få elementer
• legg til elementer mellom to tall
• Sortering av elementer
• ArrayList-størrelse

Operasjoner utført i ArrayList

1. Legge til elementer

For å legge til et element i en ArrayList, kan vi bruke add() metode . Denne metoden er overbelastet for å utføre flere operasjoner basert på forskjellige parametere. De er som følger:

• add(Object): Denne metoden brukes til å legge til et element på slutten av ArrayList.
• add(int index, Object): Denne metoden brukes til å legge til et element ved en spesifikk indeks i ArrayList.

Nedenfor er implementeringen av tilnærmingen ovenfor:

// 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();  // Legge til elementer i ArrayList // Egendefinerte innganger al.add('Geeks');  al.add('Geeks');  // Her nevner vi indeksen // som den skal legges til al.add(1, 'For');  // Skrive ut alle elementene i et ArrayList System.out.println(al);  } }>

[Geeks, For, Geeks]>

2. Endre elementer

Etter å ha lagt til elementene, hvis vi ønsker å endre elementet, kan det gjøres ved å bruke sett() metode. Siden en ArrayList er indeksert, blir elementet som vi ønsker å endre referert til av indeksen til elementet. Derfor tar denne metoden en indeks og det oppdaterte elementet som må settes inn i den indeksen.

Nedenfor er implementeringen av tilnærmingen ovenfor:

// 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();  // Legge til elementer til Arraylist // Egendefinerte input-elementer al.add('Geeks');  al.add('Geeks');  // Adding spesifiserer indeksen som skal legges til al.add(1, 'Geeks');  // Skrive ut Arraylist-elementene System.out.println('Initial ArrayList ' + al);  // Innstillingselement ved 1. indeks al.set(1, 'For');  // Skriver ut den oppdaterte Arraylist System.out.println('Updated ArrayList ' + al);  } }>

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

3. Fjerning av elementer

For å fjerne et element fra en ArrayList, kan vi bruke remove() metoden . Denne metoden er overbelastet for å utføre flere operasjoner basert på forskjellige parametere. De er som følger:

• fjern (objekt): Denne metoden brukes til å fjerne et objekt fra ArrayList. Hvis det er flere slike objekter, fjernes den første forekomsten av objektet.
• remove(int index): Siden en ArrayList er indeksert, tar denne metoden en heltallsverdi som ganske enkelt fjerner elementet som er tilstede på den spesifikke indeksen i ArrayList. Etter å ha fjernet elementet, flyttes alle elementene til venstre for å fylle plassen og indeksene til objektene oppdateres.

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();  // Legge til elementer til ArrayList // Egendefinert tillegg al.add('Geeks');  al.add('Geeks');  // Legger til element ved spesifikk indeks al.add(1, 'For');  // Skriver ut alle elementene i ArrayList System.out.println('Initial ArrayList ' + al);  // Fjerner element ovenfra ArrayList al.remove(1);  // Skrive ut de oppdaterte Arraylist-elementene System.out.println('Etter indeksfjerningen ' + al);  // Fjerner dette ordelementet i ArrayList al.remove('Geeks');  // Skriver nå ut oppdatert ArrayList System.out.println('Etter at objektet er fjernet ' + al);  } }>

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

4. Iterering av ArrayList

Det er flere måter å iterere gjennom ArrayList. De mest kjente måtene er ved å bruke de grunnleggende for løkke i kombinasjon med en get() metoden for å få elementet på en bestemt indeks og avansert for en loop .

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();  // Legge til elementer i ArrayList // ved å bruke standard add() metode al.add('Geeks');  al.add('Geeks');  al.add(1, 'For');  // Ved å bruke 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. Få 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();  // legg til nummerlisten.add(9);  list.add(5);  liste.legg til(6);  System.out.println(liste);  // få metode Heltall n= liste.get(1);  System.out.println('at indext 1 nummer er:'+n);  } }>

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

6. Legg til elementer mellom to tall

// 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();  liste.legg til(1);  liste.legg til(2);  liste.legg til(4);  System.out.println(liste);  // sett inn manglende element 3 list.add(2, 3);  System.out.println(liste);  } }>

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

7. ArrayList Sorter

// Java Program for ArrayList Sorting import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList list = new ArrayList();  liste.legg til(2);  liste.legg til(4);  liste.legg til(3);  liste.legg til(1);  System.out.println('Før sorteringsliste:');  System.out.println(liste);  Collections.sort(liste);  System.out.println('etter sorteringsliste:');  System.out.println(liste);  } }>

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

8. Størrelse på 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();  liste.legg til(1);  liste.legg til(2);  liste.legg til(3);  liste.legg til(4);  int b = liste.størrelse();  System.out.println('Størrelsen er :' + b);  } }>

The size is :4>

Kompleksiteten til Java ArrayList

ArrayList i Java er en klasse i Java Collections-rammeverket som implementerer List-grensesnittet. Her er fordelene og ulempene ved å bruke ArrayList i Java.

Fordeler med Java ArrayList

1. Dynamisk størrelse: ArrayList kan dynamisk vokse og krympe i størrelse, noe som gjør det enkelt å legge til eller fjerne elementer etter behov.
2. Enkel å bruke: ArrayList er enkel å bruke, noe som gjør den til et populært valg for mange Java-utviklere.
3. Rask tilgang: ArrayList gir rask tilgang til elementer, da den er implementert som en array under panseret.
4. Ordnet samling: ArrayList bevarer rekkefølgen på elementene, slik at du får tilgang til elementene i den rekkefølgen de ble lagt til.
5. Støtter nullverdier: ArrayList kan lagre nullverdier, noe som gjør det nyttig i tilfeller der fraværet av en verdi må representeres.

Ulemper med Java ArrayList

1. Tregere enn matriser: ArrayList er tregere enn matriser for visse operasjoner, for eksempel å sette inn elementer i midten av listen.
2. Økt minnebruk: ArrayList krever mer minne enn arrays, ettersom den trenger å opprettholde sin dynamiske størrelse og håndtere endring av størrelse.
3. Ikke trådsikker: ArrayList er ikke trådsikker, noe som betyr at flere tråder kan få tilgang til og endre listen samtidig, noe som fører til potensielle løpsforhold og datakorrupsjon.
4. Ytelsesdegradering: ArrayLists ytelse kan forringes etter hvert som antallet elementer i listen øker, spesielt for operasjoner som å søke etter elementer eller sette inn elementer midt på listen.

Konklusjon

Punkter som bør huskes fra denne artikkelen er nevnt nedenfor:

• ArrayList er en del av samlingsrammeverket. Den arver AbstractList-klassen og implementerer List-grensesnittet.
• ArrayList er implementeringen av en dynamisk matrise.
• ArrayList kan initialiseres brukt ved å bruke forskjellige konstruktørtyper som uten parametere, å sende samling som en parameter og å sende heltall som en parameter.
• Operasjoner kan utføres i ArrayList som følger Legge til, fjerne, iterere og sortere.

Vanlige spørsmål om ArrayList

Hva er en ArrayList i Java?

ArrayList i Java er en del av samlingsrammeverket. Den brukes til å lagre elementer og størrelsen kan endres.

Hvordan lagres data i ArrayList?

ArrayList kan lagre data til ArrayList-størrelsen er full, etter det dobles størrelsen på ArrayList hvis vi ønsker å lagre flere elementer.

Tillater ArrayList duplikater?

Ja, ArrayList tillater lagring av dupliserte verdier.