Meniu

Java ArrayList - Cum să declarați, inițializați și tipăriți o listă Array

  • Principal
  • Alte
  • Java ArrayList - Cum să declarați, inițializați și tipăriți o listă Array

java arraylist how declare

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acest tutorial explică cum să declarați, inițializați și tipăriți Java ArrayList cu exemple de cod. De asemenea, veți afla despre Arraylist 2D și implementarea ArrayList în Java:

Java Collections Framework și interfața List au fost explicate în detaliu în tutorialele noastre anterioare. ArrayList este o structură de date care face parte din cadrul colecțiilor și poate fi văzută ca similară cu matricele și vectorii.

ArrayList poate fi perceput ca un tablou dinamic care vă permite să adăugați sau să eliminați elemente din el în orice moment sau pur și simplu spus, dinamic.

=> Consultați aici Ghidul pentru începători Java.

ArrayList în Java

Cu alte cuvinte, dimensiunea sa poate crește sau scădea dinamic, spre deosebire de tablourile a căror dimensiune rămâne statică după declarare.

Ce veți învăța:

Clasa ArrayList În Java

Structura de date ArrayList din Java este reprezentată de clasa ArrayList care face parte din „ java.util ' pachet.

Ierarhia pentru clasa ArrayList este prezentată mai jos.

Ierarhia pentru clasa ArrayList

După cum puteți vedea, clasa ArrayList implementează interfața List care, la rândul său, se extinde de la interfața Colecție.

Definiția generală a clasei ArrayList este dată mai jos:

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

Iată câteva dintre caracteristicile distinctive ale ArrayList:

  • Clasa ArrayList de Java stochează elemente menținând ordinea de inserare.
  • ArrayList permite duplicarea elementelor stocate în ea.
  • ArrayList nu este sincronizat, punctul principal care diferențiază ArrayList de clasa Vector din Java.
  • ArrayList în Java este mai identic cu vectorii din C ++.
  • ArrayList în Java folosește, de asemenea, indici precum matrici și acceptă accesul aleatoriu.
  • Operațiunile care manipulează elementele din ArrayList sunt lente, deoarece trebuie să se facă o mulțime de schimbări de elemente dacă vreun element trebuie eliminat din ArrayList.
  • Clasa ArrayList nu poate conține tipuri primitive, ci doar obiecte. În acest caz, de obicei îl numim „ArrayList of objects”. Deci, dacă doriți să stocați tipul întreg de elemente, atunci trebuie să utilizați obiectul Integer al clasei wrapper și nu tipul primitiv int.

Creați și declarați ArrayList

Pentru a utiliza clasa ArrayList în programul dvs., trebuie să o includeți mai întâi în programul dvs. folosind directiva „import”, așa cum se arată mai jos:

import java.util.ArrayList;

SAU

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

Odată ce ați importat clasa ArrayList în programul dvs., puteți crea un obiect ArrayList.

Sintaxa generală de creare a ArrayList este:

ArrayList arrayList = new ArrayList ();

În afară de declarația de mai sus care folosește constructorul implicit, clasa ArrayList oferă și alți constructori supraîncărcați pe care îi puteți folosi pentru a crea ArrayList.

Metode constructoare

Clasa ArrayList din Java oferă următoarele metode de constructor pentru a crea ArrayList.

Metoda # 1: ArrayList ()

Această metodă utilizează constructorul implicit al clasei ArrayList și este utilizată pentru a crea un ArrayList gol.

Sintaxa generală a acestei metode este:

ArrayList list_name = new ArrayList();

De exemplu, puteți crea o ArrayList generică de tip String folosind următoarea declarație.

ArrayList arraylist = new ArrayList();

Aceasta va crea o ArrayList goală numită „arraylist” de tip String.

Metoda # 2: ArrayList (capacitate int)

Acest constructor supraîncărcat poate fi folosit pentru a crea un ArrayList cu dimensiunea sau capacitatea specificată furnizate ca argument pentru constructor.

Sintaxa generală pentru această metodă este:

ArrayList list_name = new ArrayList(int capacity);

Exemplu:

ArrayList arraylist = new ArrayList(10);

Afirmația de mai sus creează o ArrayList goală numită „arraylist” de tip Integer cu capacitatea 10.

Metoda # 3: ArrayList (Colecția c)

Al treilea constructor supraîncărcat pentru clasa ArrayList ia o colecție deja existentă ca argument și creează o ArrayList cu elementele din colecția specificată c ca elemente inițiale.

Sintaxa generală pentru inițializarea ArrayList folosind acest constructor este:

ArrayList list_name = new ArrayList (Collection c)

De exemplu, dacă intList este o colecție existentă cu elemente {10,20,30,40,50}, atunci următoarea declarație va crea o listă „arraylist” cu conținutul intList ca elemente inițiale.

ArrayList ArrayList = new ArrayList(intList);

Clasa ArrayList acceptă, de asemenea, diverse metode care pot fi utilizate pentru a manipula conținutul listei. Vom discuta aceste metode în detaliu în viitorul nostru tutorial „Metode ArrayList în Java”.

Inițializați ArrayList în Java

Odată ce ArrayList este creat, există mai multe moduri de a inițializa ArrayList cu valori. În această secțiune, vom discuta aceste modalități.

# 1) Utilizarea Arrays.asList

Aici, puteți trece un Array convertit în Listă folosind metoda asList din clasa Arrays pentru a inițializa ArrayList.

Sintaxă generală:

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

Exemplu:

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); } }

Ieșire:

Inițializați ArrayList în Java

# 2) Folosirea metodei clasei interioare anonime

Aici folosim clasa interioară anonimă pentru a inițializa ArrayList la valori.

Sintaxa generală pentru utilizarea unei clase interioare anonime pentru inițializarea ArrayList este după cum urmează:

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

Exemplu:

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); } }

Ieșire:

Folosind metoda clasei interioare anonime

# 3) Folosind add method

Aceasta este metoda obișnuită de a adăuga elemente la orice colecție.

Sintaxa generală pentru utilizarea metodei add pentru a adăuga elemente la ArrayList este:

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

Exemplu de programare:

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); }

Ieșire:

Folosind metoda add

# 4) Utilizarea metodei Collection.nCopies

Această metodă este utilizată pentru a inițializa ArrayList cu aceleași valori. Furnizăm numărul de elemente care trebuie inițializate și valoarea inițială a metodei.

Sintaxa generală a inițializării este:

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

Exemplul de mai jos demonstrează inițializarea matricei folosind metoda 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); } }

Ieșire:

Folosind metoda Collection.nCopies

Iterarea prin ArrayList

Avem următoarele modalități de a parcurge sau de a parcurge ArrayList:

  1. Folosind bucla
  2. Prin buclă pentru fiecare buclă (pentru buclă îmbunătățită).
  3. Folosind interfața Iterator.
  4. Prin interfața ListIterator.
  5. Prin metoda forEachRemaining ().

De fapt, aceste metode sunt utilizate pentru a itera prin colecții în general. Vom vedea exemple de fiecare dintre metodele cu privire la ArrayList în acest tutorial.

# 1) Folosind bucla

O buclă bazată pe index poate fi utilizată pentru a traversa ArrayList și a imprima elementele sale.

Următorul este un exemplu de traversare și tipărire a ArrayList folosind bucla for.

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

Ieșire:

Prin metoda forEachRemaining ()

Acesta este cel mai simplu și simplu mod de a traversa și tipări elementele ArrayList și funcționează în același mod și în cazul altor colecții.

# 2) Pentru fiecare buclă (îmbunătățită pentru buclă)

De asemenea, puteți parcurge ArrayList folosind o buclă pentru fiecare sau bucla îmbunătățită pentru. Înainte de Java 8, nu includea expresii lambda. Dar, începând cu Java 8, puteți include și expresii Lambda în bucla pentru fiecare.

Programul de mai jos demonstrează traversarea și tipărirea ArrayList folosind pentru fiecare buclă și expresie lambda.

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 + ' '); }); } }

Ieșire:

După fiecare buclă

# 3) Utilizarea interfeței Iterator

Am văzut în detaliu interfața Iterator în subiectele noastre anterioare. Interfața Iterator poate fi utilizată pentru a itera prin ArrayList și a imprima valorile sale.

Următorul program arată acest lucru.

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() + ' '); } } }

Ieșire:

Folosind interfața Iterator

# 4) Prin interfața ListIterator

De asemenea, puteți parcurge ArrayList folosind ListIterator. ListIterator poate fi folosit pentru a parcurge ArrayList în direcția înainte și înapoi.

Să implementăm un program Java care demonstrează un exemplu de utilizare a 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 + ' '); } } }

Ieșire:

Prin interfața ListIterator

După cum puteți vedea din ieșire, în programul de mai sus ArrayList este parcurs în direcție inversă folosind metodele hasPrevious () și previous () ale ListIterator.

# 5) Prin metoda forEachRemaining ()

Aceasta este una dintre metodele de parcurgere a ArrayList și este disponibilă din Java 8.

Următorul program demonstrează metoda forEachRemaining () pentru a traversa 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 + ' '); }); } }

Ieșire:

Prin metoda forEachRemaining ()

întrebări de interviu pl sql pentru experimentați

Folosim metoda forEachRemaining () împreună cu un Iterator. Este similar cu fiecare și folosim expresia lambda în această metodă.

ArrayList Exemplu Java

În această secțiune, vom vedea implementarea ArrayList în Java. De exemplu, vom implementa un exemplu complet de la crearea, inițializarea și utilizarea Java ArrayList pentru a efectua diverse manipulări.

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); } }

Ieșire:

ArrayList java exemplu

ArrayList bidimensional în Java

Știm că un ArrayList nu are dimensiuni precum Array. Însă putem avea cuiburi ArrayLists care sunt numite și „2D ArrayLists” sau „ArrayList of ArrayLists”.

Ideea simplă din spatele acestor ArrayLists imbricate este că, având în vedere o ArrayList, fiecare element al acestei ArrayList este un alt ArrayList.

Să înțelegem acest lucru folosind următorul 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

Ieșire:

ArrayList bidimensional în Java

Programul de mai sus prezintă 2D ArrayList. Aici, mai întâi, declarăm ArrayList de ArrayLists. Apoi definim ArrayLists individuale care vor servi ca elemente individuale ale ArrayList imbricate atunci când adăugăm fiecare dintre aceste ArrayLists la Nested ArrayList.

Pentru a accesa fiecare element al ArrayList, trebuie să apelăm metoda get de două ori. Mai întâi pentru a accesa rândul Nested ArrayList și apoi pentru a accesa intersecția individuală a rândului și a coloanei.

Rețineți că puteți crește nivelurile imbricate ale ArrayList pentru a defini ArrayLists multi-dimensionale. De exemplu, 3D ArrayList va avea ca elemente 2D ArrayLists și așa mai departe.

întrebări frecvente

Q # 1) Ce este ArrayList în Java?

Răspuns: Un ArrayList în Java este un tablou dinamic. Este redimensionabil în natură, adică crește în dimensiune atunci când se adaugă elemente noi și se micșorează atunci când elementele sunt șterse.

Q # 2) Care este diferența dintre Array și ArrayList?

Răspuns: O matrice este în structură statică și dimensiunea sa nu poate fi modificată odată declarată. Un ArrayList este un tablou dinamic și își schimbă dimensiunea atunci când elementele sunt adăugate sau eliminate.

Matricea este o structură de bază în Java, în timp ce o ArrayList face parte din cadrul de colecție în Java. O altă diferență este că, în timp ce Array folosește subscript (()) pentru a accesa elemente, ArrayList folosește metode pentru a accesa elementele sale.

Î # 3) Este ArrayList o listă?

Răspuns: ArrayList este un subtip al listei. ArrayList este o clasă, în timp ce List este o interfață.

Q # 4) ArrayList este o colecție?

Răspuns: Nu. ArrayList este o implementare a Colecției care este o interfață.

Q # 5) Cum își mărește ArrayList dimensiunea?

Răspuns: Intern ArrayList este implementat ca un Array. ArrayList are un parametru de dimensiune. Când elementele sunt adăugate la ArrayList și valoarea dimensiunii este atinsă, ArrayList adaugă intern o altă matrice pentru a găzdui elemente noi.

Concluzie

Acesta a fost tutorialul de bază al clasei ArrayList din Java. Am văzut crearea și inițializarea clasei ArrayList împreună cu o implementare detaliată a programării ArrayList.

Am discutat, de asemenea, ArrayLists 2D și multidimensionale. Clasa ArrayList acceptă diferitele metode pe care le putem folosi pentru a manipula elementele. În tutorialele noastre viitoare, vom lua în considerare aceste metode.

=> Citiți seria Easy Training Java.

Lectură recomandată

^