Clasa ArrayList și interfața List

Pentru a crea liste simple se utilizează interfața List, care extinde funcționalitatea interfeței Collection. Câteva dintre cele mai frecvent utilizate metode ale interfeței List sunt:

• void add(int index, E obj): adaugă obiectul obj la lista de la indexul index
• boolean addAll(int index, Collection<? extends E> col): adaugă toate elementele din colecția col la indexul specificat. Returnează true dacă lista a fost modificată, altfel false
• E get(int index): returnează obiectul de la indexul index din listă
• int indexOf(Object obj): returnează indexul primei apariții a obiectului obj în listă. Dacă obiectul nu este găsit, returnează -1
• int lastIndexOf(Object obj): returnează indexul ultimei apariții a obiectului obj în listă. Dacă obiectul nu este găsit, returnează -1
• ListIterator<E> listIterator(): returnează un obiect ListIterator pentru parcurgerea elementelor listei
• static <E> List<E> of(elemente): creează un obiect List dintr-un set de elemente
• E remove(int index): elimină obiectul de la indexul index din listă și returnează obiectul eliminat
• E set(int index, E obj): înlocuiește elementul de la indexul index cu obiectul obj
• void sort(Comparator<? super E> comp): sortează lista folosind comparatorul comp
• List<E> subList(int start, int end): obține un subset de elemente din listă, între indexurile start și end

În mod implicit, Java oferă o implementare a acestei interfețe prin clasa ArrayList. Clasa ArrayList reprezintă o colecție generică, moștenind funcționalitatea din clasa AbstractList și implementând interfața List. Pe scurt, ArrayList este o listă simplă, asemănătoare unui tablou (array), dar cu număr dinamic de elemente.

Constructorii clasei ArrayList

• ArrayList(): creează o listă goală
• ArrayList(Collection<? extends E> col): creează o listă care conține toate elementele din colecția col
• ArrayList(int capacity): creează o listă cu o capacitate inițială specificată

Capacitatea inițială a unui ArrayList reprezintă dimensiunea tabloului utilizat pentru stocarea obiectelor. Dacă adăugăm mai multe elemente decât capacitatea inițială, memoria este realocată - un nou tablou este creat, iar elementele din tabloul vechi sunt copiate în cel nou. Specificarea capacității inițiale reduce astfel de realocări, îmbunătățind performanța.

Exemplu de utilizare a clasei ArrayList:

import java.util.ArrayList;

public class Program {
     
   public static void main(String[] args) {
         
       ArrayList<String> people = new ArrayList<String>();
       // adăugăm câteva elemente în listă
       people.add("Tom");
       people.add("Alice");
       people.add("Kate");
       people.add("Sam");
       people.add(1, "Bob"); // adăugăm un element la indexul 1
         
       System.out.println(people.get(1)); // obținem al doilea obiect
       people.set(1, "Robert"); // setăm o nouă valoare pentru al doilea obiect
         
       System.out.printf("ArrayList are %d elemente \n", people.size());
       for (String person : people) {
           System.out.println(person);
       }
       // verificăm prezența unui element
       if (people.contains("Tom")) {
           System.out.println("ArrayList conține Tom");
       }
         
       // eliminăm câteva obiecte
       people.remove("Robert"); // eliminăm un obiect specific
       people.remove(0); // eliminăm obiectul de la indexul 0
         
       Object[] peopleArray = people.toArray();
       for (Object person : peopleArray) {
           System.out.println(person);
       }
   }
}

Output-ul programului în consolă:

Bob
ArrayList are 5 elemente
Tom
Robert
Alice
Kate
Sam
ArrayList conține Tom
Alice
Kate
Sam

În acest exemplu, obiectul ArrayList este tipizat cu String, deci lista va stoca doar șiruri de caractere. Deoarece clasa ArrayList implementează interfața Collection<E>, putem folosi metodele acestei interfețe pentru gestionarea obiectelor din listă.

Pentru adăugarea de elemente se folosește metoda add(), care adaugă un obiect la sfârșitul listei: people.add("Tom"). De asemenea, putem adăuga un obiect la un index specific, de exemplu, la poziția a doua (indexul 1): people.add(1, "Bob").

Metoda size() returnează numărul de obiecte din colecție.

Pentru verificarea prezenței unui element în colecție, se utilizează metoda contains(), iar pentru eliminare metoda remove(). Similar cu adăugarea, putem elimina fie un obiect specific (people.remove("Tom")), fie un obiect de la un anumit index (people.remove(0)).

Pentru obținerea unui element specific din listă, folosim metoda get(): String person = people.get(1);, iar pentru a seta un element folosim set(): people.set(1, "Robert").

Metoda toArray() convertește lista într-un tablou de obiecte.

Deoarece clasa ArrayList implementează interfața Iterable, putem parcurge lista folosind ciclul for-each: for (String person : people).

Deși putem adăuga în mod liber elemente într-un obiect ArrayList, în realitate acesta utilizează un tablou pentru a stoca obiectele. În mod implicit, acest tablou are capacitatea de a stoca 10 obiecte. Dacă adăugăm mai multe elemente, se creează un nou tablou cu capacitate mai mare.

Aceste realocări de memorie reduc performanța. De aceea, dacă știm dinainte câte elemente va conține lista, putem seta explicit această capacitate fie în constructor (ArrayList<String> people = new ArrayList<String>(25);), fie cu metoda ensureCapacity(): people.ensureCapacity(25);.