Menu

Java ArrayList - Sådan erklæres, initialiseres og udskrives en ArrayList

  • Vigtigste
  • Andet
  • Java ArrayList - Sådan erklæres, initialiseres og udskrives en ArrayList

java arraylist how declare

Prøv Vores Instrument Til At Fjerne Problemer

Denne vejledning forklarer, hvordan man erklærer, initialiserer og udskriver Java ArrayList med kodeeksempler. Du vil også lære om 2D Arraylist & Implementation of ArrayList in Java:

Java Collections Framework og grænsefladen List blev forklaret detaljeret i vores tidligere tutorials. ArrayList er en datastruktur, der er en del af Collections Framework og kan ses som svarende til arrays og vektorer.

ArrayList kan opfattes som et dynamisk array, der giver dig mulighed for at tilføje eller fjerne elementer fra det når som helst eller simpelthen sagt dynamisk.

=> Se på Java Beginners Guide her.

ArrayList i Java

Med andre ord kan dens størrelse øges eller formindskes dynamisk i modsætning til arrays, hvis størrelse forbliver statisk, når de er deklareret.

Hvad du lærer:

ArrayList-klasse i Java

ArrayList-datastrukturen i Java er repræsenteret af ArrayList-klassen, som er en del af “ java.util ' pakke.

Hierarkiet for ArrayList-klassen er vist nedenfor.

Hierarki for ArrayList-klassen

Som du kan se, implementerer ArrayList-klassen List-grænsefladen, som igen strækker sig fra Collection-grænsefladen.

Den generelle definition af ArrayList-klassen er angivet nedenfor:

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

Her er nogle af de karakteristiske egenskaber ved ArrayList:

  • ArrayList-klassen af ​​Java gemmer elementer ved at opretholde indsætningsrækkefølgen.
  • ArrayList tillader duplikatelementer, der er gemt i den.
  • ArrayList er ikke synkroniseret, det største punkt, der adskiller ArrayList fra Vector-klassen i Java.
  • ArrayList i Java er mere identisk med vektorer i C ++.
  • ArrayList i Java bruger også indekser som arrays og understøtter tilfældig adgang.
  • De operationer, der manipulerer elementer i ArrayList, er langsomme, da der skal foretages en masse forskydning af elementer, hvis et element skal fjernes fra ArrayList.
  • ArrayList-klassen kan ikke indeholde primitive typer, men kun objekter. I dette tilfælde kalder vi det normalt som 'ArrayList of objects'. Så hvis du vil gemme heltal elementtyper, skal du bruge heltal-objektet i indpakningsklassen og ikke primitiv type int.

Opret og erklær ArrayList

For at kunne bruge ArrayList-klassen i dit program skal du først inkludere den i dit program ved hjælp af 'import'-direktivet som vist nedenfor:

import java.util.ArrayList;

ELLER

import java.util.*; //this will include all classes from java.util package

Når du har importeret ArrayList-klassen i dit program, kan du oprette et ArrayList-objekt.

Den generelle syntaks for oprettelse af ArrayList er:

ArrayList arrayList = new ArrayList ();

Bortset fra ovenstående udsagn, der bruger standardkonstruktør, giver ArrayList-klassen også andre overbelastede konstruktører, som du kan bruge til at oprette ArrayList.

Konstruktørmetoder

ArrayList-klassen i Java giver følgende konstruktormetoder til at oprette ArrayList.

Metode nr. 1: ArrayList ()

Denne metode bruger standardkonstruktøren til ArrayList-klassen og bruges til at oprette en tom ArrayList.

Den generelle syntaks for denne metode er:

ArrayList list_name = new ArrayList();

For eksempel, Du kan oprette en generisk ArrayList af typen String ved hjælp af følgende udsagn.

ArrayList arraylist = new ArrayList();

Dette opretter en tom ArrayList med navnet 'arraylist' af typen String.

Metode nr. 2: ArrayList (int-kapacitet)

Denne overbelastede konstruktør kan bruges til at oprette en ArrayList med den angivne størrelse eller kapacitet, der er angivet som et argument til konstruktøren.

Den generelle syntaks for denne metode er:

ArrayList list_name = new ArrayList(int capacity);

Eksempel:

ArrayList arraylist = new ArrayList(10);

Ovenstående udsagn opretter en tom ArrayList med navnet 'arraylist' af typen Integer med kapacitet 10.

Metode nr. 3: ArrayList (samling c)

Den tredje overbelastede konstruktør til ArrayList-klassen tager en allerede eksisterende samling som et argument og opretter en ArrayList med elementerne fra den angivne samling c som dens indledende elementer.

Den generelle syntaks for ArrayList initialisering ved hjælp af denne konstruktør er:

ArrayList list_name = new ArrayList (Collection c)

For eksempel, hvis intList er en eksisterende samling med elementerne {10,20,30,40,50}, vil følgende udsagn oprette en liste 'arraylist' med indholdet af intList som dens indledende elementer.

ArrayList ArrayList = new ArrayList(intList);

ArrayList-klassen understøtter også forskellige metoder, der kan bruges til at manipulere indholdet på listen. Vi vil diskutere disse metoder detaljeret i vores kommende tutorial 'ArrayList-metoder i Java'.

Initialiser ArrayList i Java

Når ArrayList er oprettet, er der flere måder at initialisere ArrayList med værdier på. I dette afsnit vil vi diskutere disse måder.

# 1) Brug af Arrays.asList

Her kan du videregive en matrix konverteret til liste ved hjælp af asList-metoden i Arrays-klassen for at initialisere ArrayList.

Generel syntaks:

ArrayList arrayListName = new ArrayList( Arrays.asList (Object o1, Object o2, …, Object on));

Eksempel:

import java.util.*; public class Main { public static void main(String args()) { //create and initialize ArrayList object myList with Arrays.asList method ArrayList myList = new ArrayList( Arrays.asList('One', 'Two', 'Three')); //print the ArrayList System.out.println('List contents:'+myList); } }

Produktion:

Initialiser ArrayList i Java

# 2) Brug af Anonym indre klassemetode

Her bruger vi den anonyme indre klasse til at initialisere ArrayList til værdier.

Den generelle syntaks til brug af en anonym indre klasse til ArrayList-initialisering er som følger:

ArrayListarraylistName = new ArrayList(){{ add(Object o1); add (Object o2);… add (Object on);}};

Eksempel:

import java.util.*; public class Main { public static void main(String args()) { //create and initialize ArrayList with anonymous inner class calls ArrayList colors = new ArrayList(){{ add('Red'); add('Blue'); add('Purple'); }}; //print the ArrayList System.out.println('Content of ArrayList:'+colors); } }

Produktion:

Brug af Anonym indre klassemetode

# 3) Brug af tilføjelsesmetode

Dette er den almindelige metode til at tilføje elementer til enhver samling.

Den generelle syntaks til brug af add-metode til at føje elementer til ArrayList er:

ArrayListArraylistName = new ArrayList(); ArraylistName.add(value1); ArraylistName.add(value2); ArraylistName.add(value3);

Programmeringseksempel:

import java.util.*; public class Main { public static void main(String args()) { //create ArrayList ArrayList colors = new ArrayList(); //add elements to the ArrayList using add method colors.add('Red'); colors.add('Green'); colors.add('Blue'); colors.add('Orange'); //print the ArrayList System.out.println('Content of ArrayList:'+colors); }

Produktion:

Brug add-metoden

# 4) Brug af Collection.nCopies-metoden

Denne metode bruges til at initialisere ArrayList med de samme værdier. Vi giver antallet af elementer, der skal initialiseres, og den oprindelige værdi til metoden.

Den generelle syntaks for initialisering er:

ArrayList arrayListName = new ArrayList(Collections.nCopies(count, element));

Nedenstående eksempel viser initialisering af array ved hjælp af metoden Collections.nCopies.

import java.util.*; public class Main { public static void main(String args()) { //create ArrayList with 10 elements //initialized to value 10 using Collections.nCopies ArrayList intList = new ArrayList(Collections.nCopies(10,10)); //print the ArrayList System.out.println('Content of ArrayList:'+intList); } }

Produktion:

Brug af metoden Collection.nCopies

Iterering gennem ArrayList

Vi har følgende måder at krydse ArrayList gennem eller gennemløbe:

  1. Brug for loop
  2. Ved for-hver løkke (forbedret for-løkke).
  3. Brug af Iterator-grænsefladen.
  4. Af ListIterator-interface.
  5. Ved metoden forEachRemaining ().

Faktisk bruges disse metoder til at gentage gennem samlinger generelt. Vi vil se eksempler på hver af metoderne med hensyn til ArrayList i denne vejledning.

# 1) Brug af til loop

En indeksbaseret for loop kan bruges til at krydse ArrayList og udskrive dens elementer.

Følgende er et eksempel på at krydse og udskrive ArrayList ved hjælp af for loop.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using for-loop:'); //use for loop to traverse through its elements and print it for(int i=0;i

Produktion:

Ved metoden forEachRemaining ()

Dette er den enkleste og nemmeste måde at krydse og udskrive elementerne i ArrayList på og fungerer på samme måde i tilfælde af andre samlinger.

# 2) Ved for-hver loop (forbedret til loop)

Du kan også krydse ArrayList ved hjælp af en for-hver loop eller den forbedrede for loop. Før Java 8 inkluderede den ikke lambda-udtryk. Men fra Java 8 og fremefter kan du også inkludere Lambda-udtryk i for-hver løkke.

Programmet nedenfor viser gennemkørsel og udskrivning af ArrayList ved hjælp af hver loop og lambda-udtryk.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using for-each loop:'); //use for-each loop to traverse through its elements and print it intList.forEach(val ->{ System.out.print(val + ' '); }); } }

Produktion:

Ved for-hver løkke

# 3) Brug af Iterator Interface

Vi har set Iterator-grænsefladen i detaljer i vores tidligere emner. Iterator-interface kan bruges til at gentage gennem ArrayList og udskrive dens værdier.

Det følgende program viser dette.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using Iterator interface:'); //Traverse through the ArrayList using iterator Iterator iter=arraylist.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } } }

Produktion:

Brug af Iterator-interface

# 4) Af ListIterator-interface

Du kan også krydse ArrayList ved hjælp af ListIterator. ListIterator kan bruges til at krydse ArrayList både fremad og tilbage.

Lad os implementere et Java-program, der demonstrerer et eksempel på brug af ListIterator.

import java.util.*; class Main{ public static void main(String args()){ //create a list and initiliaze it List colors_list=new ArrayList();//Creating arraylist colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Cyan'); colors_list.add('Magenta'); colors_list.add('Yellow'); System.out.println('The contents of the list using ListIterator:'); //Traverse the list using ListIterator ListIterator color_iter=colors_list.listIterator(colors_list.size()); while(color_iter.hasPrevious()) { String str=color_iter.previous(); System.out.print(str + ' '); } } }

Produktion:

Af ListIterator-interface

Som du kan se fra output, gennemgås ArrayList i ovenstående program i bagudgående retning ved hjælp af hasPrevious () og tidligere () metoder i ListIterator.

# 5) Ved forEachRemaining () metode

Dette er en af ​​metoderne til at krydse ArrayList og er tilgængelig siden Java 8.

Følgende program viser metoden forEachRemaining () til at krydse ArrayList.

import java.util.*; class Main{ public static void main(String args()){ //create a list and initiliaze it List colors_list=new ArrayList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Cyan'); colors_list.add('Magenta'); colors_list.add('Yellow'); System.out.println('The contents of the list using forEachRemaining() method:'); //Traverse the list using forEachRemaining () method Iterator itr=colors_list.iterator(); itr.forEachRemaining(val-> //lambda expression { System.out.print(val + ' '); }); } }

Produktion:

Ved metoden forEachRemaining ()

gratis windows registry cleaner og reparation

Vi bruger metoden forEachRemaining () sammen med en Iterator. Det ligner hver, og vi bruger lambda-udtryk inden for denne metode.

ArrayList Java-eksempel

I dette afsnit vil vi se implementeringen af ​​ArrayList i Java. Som et eksempel implementerer vi et komplet eksempel fra oprettelse, initialisering og brug af Java ArrayList til at udføre forskellige manipulationer.

import java.util.ArrayList; class Main { public static void main(String() args) { //Creating a generic ArrayList ArrayList newList = new ArrayList(); //Size of arrayList System.out.println('Original size of ArrayList at creation: ' + newList.size()); //add elements to it newList.add('IND'); newList.add('USA'); newList.add('AUS'); newList.add('UK'); //print the size after adding elements System.out.println('ArrayList size after adding elements: ' + newList.size()); //Print ArrayList contents System.out.println('Contents of the ArrayList: ' + newList); //Remove an element from the list newList.remove('USA'); System.out.println('ArrayList contents after removing element(USA): ' + newList); //Remove another element by index newList.remove(2); System.out.println('ArrayList contents after removing element at index 2: ' + newList); //print new size System.out.println('Size of arrayList: ' + newList.size()); //print list contents System.out.println('Final ArrayList Contents: ' + newList); } }

Produktion:

Eksempel på ArrayList-java

To-dimensionel ArrayList i Java

Vi ved, at en ArrayList ikke har dimensioner som Arrays. Men vi kan have indlejrede ArrayLists, som også kaldes '2D ArrayLists' eller 'ArrayList of ArrayLists'.

Den enkle idé bag disse indlejrede ArrayLists er, at givet en ArrayList, er hvert element i denne ArrayList en anden ArrayList.

Lad os forstå dette ved hjælp af følgende program.

import java.util.*; public class Main { public static void main(String() args) { int num = 3; // declare an arrayList of ArrayLists or 2D ArrayList ArrayList intList = new ArrayList (num); // Create individual elements or ArrayLists and add them to intList as elements ArrayList list_elem1 = new ArrayList(); list_elem1.add(10); intList.add(list_elem1); ArrayList list_elem2 = new ArrayList(); list_elem2.add(20); list_elem2.add(30); intList.add(list_elem2); ArrayList list_elem3 = new (); list_elem3.add(40); list_elem3.add(50); list_elem3.add(60); intList.add(list_elem3); System.out.println('Contents of 2D ArrayList(Nested ArrayList):'); //print the 2D ArrayList or nested ArrayList for (int i = 0; i

Produktion:

To-dimensionel ArrayList i Java

Ovenstående program viser 2D ArrayList. Her erklærer vi først en ArrayList of ArrayLists. Derefter definerer vi individuelle ArrayLists, der vil fungere som individuelle elementer i den indlejrede ArrayList, når vi tilføjer hver af disse ArrayLists til den nestede ArrayList.

For at få adgang til hvert element i ArrayList skal vi kalde get-metoden to gange. Først for at få adgang til rækken i den indlejrede ArrayList og derefter for at få adgang til det enkelte skæringspunkt mellem række og kolonne.

Bemærk, at du kan øge de indlejrede niveauer af ArrayList for at definere flerdimensionelle ArrayLists. For eksempel, 3D ArrayList vil have 2D ArrayLists som sine elementer og så videre.

Ofte stillede spørgsmål

Q # 1) Hvad er ArrayList i Java?

Svar: En ArrayList i Java er et dynamisk array. Det kan ændres i naturen, dvs. det øges i størrelse, når nye elementer tilføjes og krymper, når elementer slettes.

Q # 2) Hvad er forskellen mellem Array og ArrayList?

Svar: En matrix er i statisk struktur, og dens størrelse kan ikke ændres, når den først er erklæret. En ArrayList er et dynamisk array og ændrer dets størrelse, når elementer tilføjes eller fjernes.

Arrayet er en grundlæggende struktur i Java, mens en ArrayList er en del af Collection Framework i Java. En anden forskel er, at mens Array bruger abonnement (()) til at få adgang til elementer, bruger ArrayList metoder til at få adgang til dets elementer.

Q # 3) Er ArrayList en liste?

Svar: ArrayList er en undertype på listen. ArrayList er en klasse, mens List er en grænseflade.

Spørgsmål nr. 4) Er ArrayList en samling?

Svar: Nej. ArrayList er en implementering af Collection, som er en grænseflade.

Spørgsmål nr. 5) Hvordan øger ArrayList sin størrelse?

Svar: Internt ArrayList implementeres som en Array. ArrayList har en størrelsesparameter. Når elementerne føjes til ArrayList, og størrelsesværdien nås, tilføjer ArrayList internt et andet array for at imødekomme nye elementer.

Konklusion

Dette var vejledningen om det grundlæggende i ArrayList-klassen i Java. Vi har set oprettelsen og initialiseringen af ​​ArrayList-klassen sammen med en detaljeret programmeringsimplementering af ArrayList.

Vi diskuterede også 2D og flerdimensionelle ArrayLists. ArrayList-klassen understøtter de forskellige metoder, som vi kan bruge til at manipulere elementerne. I vores kommende tutorials vil vi tage disse metoder op.

=> Læs gennem Easy Java Training Series.

Anbefalet læsning

^