Java ArrayList face parte din Java cadrul colecțiilor și este o clasă a pachetului java.util. Ne oferă matrice dinamice în Java. Cu toate acestea, poate fi mai lent decât matricele standard, dar poate fi util în programele în care este nevoie de multă manipulare în matrice. Această clasă se găsește în java.util pachet. Principalul avantajul ArrayList în Java este că, dacă declarăm o matrice, atunci trebuie să menționăm dimensiunea, dar în ArrayList, nu este necesar să menționăm dimensiunea ArrayList. Dacă doriți să menționați dimensiunea, o puteți face.

Cuprins

• Ce este ArrayList în Java?
• Exemplu Java ArrayList
• Caracteristici importante ale ArrayList în Java
• Constructori în ArrayList
• ArrayList în metodele Java
• Operații efectuate în ArrayList
• Complexitatea Java ArrayList
• Avantajele Java ArrayList
• Dezavantajele Java ArrayList
• Concluzie
• Întrebări frecvente ale ArrayList

Ce este ArrayList în Java?

ArrayList este o clasă Java implementată folosind interfața List. Java ArrayList, după cum sugerează și numele, oferă funcționalitatea unei matrice dinamice în care dimensiunea nu este fixă ​​ca matrice. De asemenea, ca parte a cadrului Colecții, are multe caracteristici care nu sunt disponibile cu matrice.

Ilustrare:

Să verificăm ArrayList cu tipul Integer Object Stocat în ea cu o imagine.

Exemplu Java ArrayList

Exemplul 1: Următoarea implementare demonstrează cum să creați și să utilizați un ArrayList cu mențiunea dimensiunii sale.

// 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 = noua ArrayList (n);  // Declararea ArrayList ArrayList arr2 = noua ArrayList ();  // Imprimarea ArrayList System.out.println('Matrice 1:' + arr1);  System.out.println('Matrice 2:' + arr2);  // Adăugarea de elemente noi la // la sfârșitul listei pentru (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]>

Explicația programului de mai sus:

ArrayList este o matrice dinamică și nu trebuie să specificăm dimensiunea în timp ce o creăm, dimensiunea matricei crește automat când adăugăm și eliminăm elemente în mod dinamic. Deși implementarea actuală a bibliotecii poate fi mai complexă, următoarea este o idee foarte de bază care explică funcționarea matricei atunci când matricea devine plină și dacă încercăm să adăugăm un element:

• Creează o memorie de dimensiuni mai mari pe memoria heap (de exemplu, memorie de dimensiune dublă).
• Copiază elementele de memorie curente în noua memorie.
• Noul articol este adăugat acum, deoarece există o memorie mai mare disponibilă acum.
• Ștergeți vechea memorie.

Caracteristici importante ale ArrayList în Java

• ArrayList moștenește AbstractList clasa și implementează Interfață Listă .
• ArrayList este inițializată după dimensiune. Cu toate acestea, dimensiunea crește automat dacă colecția crește sau se micșorează dacă obiecte sunt scoase din colectie.
• Java ArrayList ne permite să accesăm aleatoriu lista.
• ArrayList nu poate fi folosit pentru clasa de ambalare pentru astfel de cazuri.
• ArrayList în Java poate fi văzută ca un vector în C++ .
• ArrayList nu este sincronizată. Clasa sa sincronizată echivalentă în Java este Vector .

Să înțelegem Java ArrayList în profunzime . Uită-te la imaginea de mai jos:

În ilustrația de mai sus, AbstractList , CopyOnWriteArrayList , și AbstractSequentialList sunt clasele care implementează interfața listă. O funcționalitate separată este implementată în fiecare dintre clasele menționate. Sunt:

1. AbstractList: Această clasă este folosită pentru a implementa o listă nemodificabilă, pentru care trebuie doar să extindeți această clasă AbstractList și să implementați numai obține() si mărimea() metode.
2. CopyOnWriteArrayList: Această clasă implementează interfața listă. Este o versiune îmbunătățită a ArrayList în care toate modificările (adăugați, setați, eliminați etc.) sunt implementate prin realizarea unei noi copii a listei.
3. AbstractSequentialList: Această clasă implementează Interfață de colecție și clasa AbstractCollection. Această clasă este folosită pentru a implementa o listă nemodificabilă, pentru care trebuie doar să extindeți această clasă AbstractList și să implementați numai obține() si mărimea() metode.

Constructori în ArrayList în Java

Pentru a crea un ArrayList, trebuie să creăm un obiect din clasa ArrayList. Clasa ArrayList constă din diverse constructorii care permit crearea posibilă a listei de matrice. Următorii sunt constructorii disponibili în această clasă:

1. ArrayList()

Acest constructor este folosit pentru a construi o listă de matrice goală. Dacă dorim să creăm o ArrayList goală cu numele arr , atunci, poate fi creat ca:

ArrayList arr = new ArrayList();>

2. ArrayList(Colecția c)

Acest constructor este folosit pentru a construi o listă de matrice inițializată cu elementele din colecția c. Să presupunem că dorim să creăm un ArrayList arr care conține elementele prezente în colecția c, apoi poate fi creat ca:

ArrayList arr = new ArrayList(c);>

3. ArrayList (capacitate int)

Acest constructor este folosit pentru a construi o listă de matrice cu capacitatea inițială specificată. Să presupunem că dorim să creăm o ArrayList cu dimensiunea inițială N, atunci poate fi creată ca:

ArrayList arr = new ArrayList(N);>

Metode Java ArrayList

Notă: De asemenea, puteți crea un ArrayList generic:

// Crearea unui număr întreg generic ArrayList
ArrayList arrli = nou ArrayList();

Câteva puncte cheie ale ArrayList în Java

1. ArrayList este Structura de date subliniată Redimensionabilă sau Growable Array.
2. Duplicatele ArrayList sunt permise.
3. Ordinul de inserare este păstrat.
4. Sunt permise obiecte eterogene.
5. Este posibilă introducerea nulă.

Să vedem cum să efectuăm câteva operațiuni de bază pe ArrayList, așa cum este listat, pe care le vom discuta în continuare împreună cu implementarea fiecărei operațiuni.

• Adăugarea elementului la Listă/Adăugarea elementului
• Schimbarea elementelor/Setare element
• Eliminarea elementelor/Ștergerea elementului
• Elemente iteratoare
• obține elemente
• adăugați elemente între două numere
• Sortarea elementelor
• Dimensiunea ArrayList

Operații efectuate în ArrayList

1. Adăugarea de elemente

Pentru a adăuga un element la o ArrayList, putem folosi metoda add(). . Această metodă este supraîncărcată pentru a efectua mai multe operații bazate pe diferiți parametri. Acestea sunt după cum urmează:

• add(Object): Această metodă este folosită pentru a adăuga un element la sfârșitul ArrayList.
• add(int index, Object): Această metodă este folosită pentru a adăuga un element la un index specific din ArrayList.

Mai jos este implementarea abordării de mai sus:

// 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 = new ArrayList();  // Adăugarea elementelor la ArrayList // Intrări personalizate al.add('Geeks');  al.add('Geeks');  // Aici menționăm indexul // la care urmează să fie adăugat al.add(1, 'Pentru');  // Imprimarea tuturor elementelor dintr-un ArrayList System.out.println(al);  } }>>>  
  Ieșire  
[Geeks, For, Geeks]>
  
    2.    Schimbarea Elementelor
După adăugarea elementelor, dacă dorim să schimbăm elementul, se poate face folosind funcția  a stabilit()  metodă. Deoarece o ArrayList este indexată, elementul pe care dorim să-l schimbăm este referit de indexul elementului. Prin urmare, această metodă ia un index și elementul actualizat care trebuie introdus la acel index.
șir ca matrice
 
Mai jos este implementarea abordării de mai sus:
Java 
// 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 = new ArrayList();  // Adăugarea elementelor la Arraylist // Elemente de intrare personalizate al.add('Geeks');  al.add('Geeks');  // Adăugarea specificând indexul de adăugat al.add(1, 'Geeks');  // Tipărirea elementelor Arraylist System.out.println('Initial ArrayList ' + al);  // Setarea elementului la primul index al.set(1, 'Pentru');  // Imprimarea Arraylist actualizată System.out.println('Updated ArrayList ' + al);  } }>>>  
  Ieșire  Pentru a elimina un element dintr-o ArrayList, putem folosi metoda remove(). . Această metodă este supraîncărcată pentru a efectua mai multe operații bazate pe diferiți parametri. Acestea sunt după cum urmează:
 
    elimina (Obiect):    Această metodă este folosită pentru a elimina pur și simplu un obiect din ArrayList. Dacă există mai multe astfel de obiecte, atunci prima apariție a obiectului este eliminată.
    elimina (index int):    Deoarece un ArrayList este indexat, această metodă ia o valoare întreagă care pur și simplu elimină elementul prezent la acel index specific din ArrayList. După eliminarea elementului, toate elementele sunt mutate spre stânga pentru a umple spațiul și indicii obiectelor sunt actualizați.
    Exemplu:    
Java 
// 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 = new ArrayList();  // Adăugarea elementelor la ArrayList // Adăugarea personalizată al.add('Geeks');  al.add('Geeks');  // Adăugarea elementului la indexul specific al.add(1, 'Pentru');  // Imprimarea tuturor elementelor ArrayList System.out.println('Initial ArrayList' + al);  // Eliminarea elementului de mai sus ArrayList al.remove(1);  // Tipărirea elementelor Arraylist actualizate System.out.println('După eliminarea indexului' + al);  // Eliminarea acestui element de cuvânt din ArrayList al.remove('Geeks');  // Acum se imprimă ArrayList actualizat System.out.println('După eliminarea obiectului' + al);  } }>>>  
  Ieșire  Există mai multe moduri de a itera prin ArrayList. Cele mai faimoase moduri sunt folosirea modului de bază pentru buclă în combinație cu a  metoda get().  pentru a obține elementul la un index specific și  avansat pentru o buclă  .
 
    Exemplu    
Java 
// 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 = new ArrayList();  // Adăugarea elementelor la ArrayList // folosind metoda standard add() al.add('Geeks');  al.add('Geeks');  al.add(1, 'Pentru');  // Folosind metoda Get și bucla // for 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 + ' ');  } }>
   
  Ieșire   
// 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();  // adaugă lista de numere.add(9);  list.add(5);  list.add(6);  System.out.println(listă);  // get method Integer n= list.get(1);  System.out.println('la numărul indext 1 este:'+n);  } }>>>  
  Ieșire   
// 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(listă);  // inserează elementul lipsă 3 list.add(2, 3);  System.out.println(listă);  } }>>>  
  Ieșire   
// 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('Înainte de sortarea listei:');  System.out.println(listă);  Collections.sort(list);  System.out.println('după lista de sortare:');  System.out.println(listă);  } }>>>  
  Ieșire   
// 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 = list.size();  System.out.println('Dimensiunea este :' + b);  } }>>>  
  Ieșire  Complexitatea Java ArrayList
Operațiune
 
Complexitatea timpului
 
Complexitatea spațială
 
    Inserarea elementului în ArrayList    
 
O(1)
 
PE)
 
    Eliminarea elementului din ArrayList    
 
PE)
 
O(1)
 
    Traversarea elementelor în ArrayList    
 
PE)
 
PE)
 
    Înlocuirea elementelor din ArrayList    
 
O(1)
 
O(1)
 
ArrayList în Java este o clasă din cadrul Java Collections care implementează interfața List. Iată avantajele și dezavantajele utilizării ArrayList în Java.
 
Avantajele Java ArrayList
Dimensiune dinamică: ArrayList poate crește și micșora în mod dinamic în dimensiune, facilitând adăugarea sau eliminarea elementelor după cum este necesar.
Ușor de utilizat: ArrayList este simplu de utilizat, ceea ce îl face o alegere populară pentru mulți dezvoltatori Java.
Acces rapid: ArrayList oferă acces rapid la elemente, deoarece este implementat ca o matrice sub capotă.
Colecție ordonată: ArrayList păstrează ordinea elementelor, permițându-vă să accesați elementele în ordinea în care au fost adăugate.
Suportă valori nule: ArrayList poate stoca valori nule, făcându-l util în cazurile în care trebuie reprezentată absența unei valori.
Dezavantajele Java ArrayList
Mai lent decât matricele: ArrayList este mai lent decât matricele pentru anumite operațiuni, cum ar fi inserarea elementelor în mijlocul listei.
Utilizare crescută a memoriei: ArrayList necesită mai multă memorie decât matricele, deoarece trebuie să-și mențină dimensiunea dinamică și să gestioneze redimensionarea.
Nu este sigur pentru fire: ArrayList nu este sigur pentru fire, ceea ce înseamnă că mai multe fire de execuție pot accesa și modifica lista concomitent, ceea ce duce la potențiale condiții de cursă și la coruperea datelor.
Degradarea performanței: performanța ArrayList se poate degrada pe măsură ce numărul de elemente din listă crește, în special pentru operațiuni precum căutarea elementelor sau inserarea elementelor în mijlocul listei.
Concluzie
Punctele care trebuie reținute din acest articol sunt menționate mai jos:
 
ArrayList este parte a cadrului Collections. Moștenește clasa AbstractList și implementează interfața List.
ArrayList este implementarea unui tablou dinamic.
ArrayList poate fi inițializată folosind diferite tipuri de constructoare, cum ar fi fără parametri, trecerea colecției ca parametru și trecerea unui întreg ca parametru.
Operațiile pot fi efectuate în ArrayList după cum urmează Adăugarea, eliminarea, iterare și sortare.
Întrebări frecvente ale ArrayList
Ce este o ArrayList în Java?
 
ArrayList în Java este o parte a cadrului Collections. Este folosit pentru a stoca elemente, iar dimensiunea este redimensionabilă.
 
Cum sunt stocate datele în ArrayList?
 
ArrayList poate stoca date până când dimensiunea ArrayList este plină, după aceea dimensiunea ArrayList este dublată dacă dorim să stocăm mai multe elemente.
 
ArrayList permite duplicate?
 
Da, ArrayList permite stocarea valorilor duplicate.