Curs: Core Java Programming

Module: Tipurile de date obiectuale

Unitate: Colecțiile

Colecțiile sunt tipuri de date ce conțin mai multe date de același tip
sau de un tip diferit.

Această definiție este în mod evident similară cu definiția șirului, motiv

pentru care este mai ușor să explicăm conceptul de colecție prin
explicarea diferenței dintre colecție și șir.

Știm că șirul este un tip de dată ce conține un set de alte date în cadrul
său. Șirul poate accepta numai date de același tip și numai numărul de
date specificat în timpul inițializării șirului. Mai precis, dimensiunea
unui șir nu se poate modifica după inițializarea sa și nu se pot stoca
mai multe tipuri de date în cadrul unui șir. Aceste limitări sunt
rezolvate printr-o abordare diferită, ce implică existența unui obiect ce
conține alte obiecte interconectate prin referințe. Acesta permite
manipularea simplă a structurii, fiindcă putem șterge foarte simplu un
obiect din listă prin înlăturarea referinței sale sau putem adăuga un
obiect prin adăugarea unei referințe. În plus, o astfel de structură, dat
fiind faptul că este o structură obiectuală, va fi stocată în partea
dinamică a memoriei (heap) și nu vom fi limitați de dimensiunea
acestei structuri.

Pe lângă stocarea datelor, colecțiile oferă de asemenea posibilitatea de

acces și de manipulare a datelor. Pachetul java.util, ce reprezintă unul
dintre pachetele integrate de bază ale limbajului de programare Java,
conține unul dintre cele mai puternice subsisteme Java: framework-ul
Collection (Java Framework Collection JFC). Acest framework reprezintă
o ierarhie sofisticată de interfețe și clase ce susțin tehnologia de
management al datelor. În cadrul acestui framework, putem efectua
următoarele activități:

adăugarea de obiecte într-o colecție,

înlăturarea obiectelor dintr-o colecție,

căutarea obiectelor,

obținerea (utilizarea) obiectelor,

© Copyright Link group 1 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

iterația (trecerea prin) unei colecții.

Framework-ul Collection

Haideți să vedem din ce este alcătuit framework-ul menționat mai sus.

Putem spune că baza acestei ierarhii este alcătuită din două interfețe.
Acestea sunt Collection și Map.

19.1 Structura moștenirii în interfața Collection

© Copyright Link group 2 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

Imaginea 22.2 Structura moștenirii în interfața Map

Privind cele două imagini de mai sus, putem vedea că există patru
forme diferite ale colecțiilor:

List

Acestea sunt colecțiile în care putem avea elemente repetitive, în alte

cuvinte, apariții multiple ale aceluiași element. Aceste colecții mai sunt
cunoscute și drept colecții ordonate (respectă ordinea în care
elementele au fost introduse, prin urmare putem accesa un element
dacă suntem familiarizați cu indexul său). Cele mai des utilizate clase
ale acestei colecții sunt ArrayList și LinkedList.

Set

Spre deosebire de tipul de colecție precedent, în colecțiile Set, nu

există o repetiție a elementelor. Dacă introduceți un element care deja
există într-o astfel de colecție, valoarea sa va fi scrisă peste valoarea
veche. De asemenea, aceste colecții nu au nicio ordine în limbajul Java
(există o clasă a acestei colecții ce permite acest lucru, și anume
SortedSet).

Map

O mapă este un container în care elementele se stochează împreună

cu cheile. Astfel de colecții au fost deja menționate ca asociative. Într-o
astfel de structură, elementele unui șir sunt identificate în funcție de o
anumită cheie care le reprezintă. Aceste colecții nu pot avea chei
repetitive. Unele dintre implementările acestei colecții sunt: HashMap,
HashTable, TreeMap și LinkedHashMap.

Queue

© Copyright Link group 3 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

Queue reprezintă o structură cunoscută de asemenea ca FIFO (First In

First Out). Primele elemente introduse într-o astfel de colecție sunt de
asemenea primele eliminate. Această structură este identică cu
structura unei cozi din viața reală.

Colecțiile aparțin ariei de cunoștințe avansate despre Java, prin urmare

nu vom discuta decât despre acele colecții pe care le puteți utiliza la
acest nivel din curs.

Am văzut deja ce sunt interfețele și că acestea se folosesc pentru a

obliga o anumită clasă să implementeze funcțiile specificate în
interfață. În esență, este vorba de un acord. Interfețele menționate mai
sus și care există în framework-ul Collection funcționează în același
mod. De exemplu, clasa ArrayList ce reprezintă o colecție va
implementa cu siguranță interfața List. Este clar că putem de
asemenea să creăm propria noastră clasă ce va reprezenta un obiect
pentru stocarea altor obiecte, ceea ce și este scopul unei colecții. Cu
alte cuvinte, noi putem crea o clasă ce va reprezenta o colecție,
precum clasa ArrayList. În partea suplimentară a acestei lecții, veți
vedea cum se poate face acest lucru.

După cum am menționat deja, Java are mai multe clase predefinite și
obiectivul nostru este să aflăm mai multe despre unele dintre aceste
clase de bază.

Lists

Așa cum am mai menționat, cea mai utilizată listă în limbajul de

programare Java este ArryList. În textul de mai jos vom învăța cum
putem utiliza această structură complexă.

Pentru a o putea utiliza, trebuie mai întâi să utilizăm pachetul

java.util.ArrayList sau java.util* (acest pachet este necesar pentru
toate tipurile de liste menționate).

Pentru a crea un obiect de tipul ArrayList, avem nevoie de un

© Copyright Link group 4 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

constructor generic. Constructorul generic acceptă tipul de date pe

care clasa îl va manipula. (Modelul generic reprezintă un concept
avansat al programării obiectuale, așadar vom discuta despre acesta
într-unul dintre cursurile următoare.)

În primul rând, pentru această declarație elementele vor fi de tip

Object. Din acest motiv, pentru exemplele de utilizare a metodei add,
se pot adăuga atât date de tip String cât și numerice.

List myList = new ArrayList();

Adăugăm elemente în ArrayList în felul următor:

myList.add("my");
myList.add("name");
myList.add("is...");

Este evident faptul că putem adăuga elemente într-o listă creată astfel
fără ca mai întâi să fie nevoie să definim dimensiunea listei, ceea ce
înseamnă că o astfel de listă poate avea o dimensiune nelimitată. Cu
toate acestea, acest lucru are un preț, fiindcă această abordare este
mai lentă decât realizarea prin intermediul unui șir. Trebuie observat
că List reprezintă interfaţa, iar ArrayList reprezintă implementarea
acestei interfeţe. O altă clasă ce implementează interfaţa List este
LinkedList, în acest caz obiectul colecţie fiind creat astfel:

List myList = new LinkedList();

Pentru a accesa un element de pe o anumită poziție, utilizăm metoda

get. Elementele sunt numerotate la fel ca într-un șir, așadar, pentru a
accesa stringul name, vom expedia acestei metode numărul 1:

System.out.println(myList.get(1));

Pentru a elimina un element din listă, utilizăm metoda remove:

© Copyright Link group 5 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

myList.remove(1);

După execuția acestei comenzi, lista va conține următoarele elemente:

stringurile "my“ și "is...“. Aceste stringuri vor fi sortate din nou și
poziționate în modul următor:

0: my
1: is...

Vă reamintim că, după o astfel de intervenție, un șir ar arăta astfel:

0: my
1:
2: is...

În afară de adăugarea, eliminarea și căutarea elementelor, mai există

și alte funcții pe care fiecare listă le are. Acestea sunt funcțiile cu care
putem vedea dimensiunea și cu care putem verifica elementele.

Pentru a verifica dimensiunea colecției, utilizăm metoda size:

for(int i=0;i<myList.size();i++)
System.out.println(myList.get(i));

O altă metodă de parcurgere a listei este printr-o buclp for each, astfel:

for(String s : myList)
System.out.println(s);

Când discutăm despre iterația prin listă, o putem efectua în modul

următor. Această metodă este eficientă când trebuie să listăm toate
elementele unei liste, dar nu este utilă dacă dorim să efectuăm
intervenții mai serioase asupra sa, fiindcă nu expune iteratorul
(numărătorul):

for(String s : myList)
System.out.println(s);

© Copyright Link group 6 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

Listele pot accepta orice tip de date. Așadar, putem scrie în felul
următor:

ArrayList myList = new ArrayList();

myList.add("my");
myList.add("name");
myList.add("is...");
myList.add(123);

for(Object s : myList)
System.out.println(s);

Exemplul va procesa fără probleme toate toate valorile listate, deși

există o diferență în ceea ce privește tipurile. Acest lucru este posibil
deoarece colecția convertește toate elementele într-un obiect în timpul
stocării și le readuce la tipul original în timpul extragerii. Această
acțiune se numește Boxing și Unboxing.

Foarte adesea avem nevoie să verificăm dacă o listă conține o valoare.

Acest lucru se poate face manual:

for(Object s : myList)
if(s.equals("name"))
System.out.println("Value exists");

Însă, interfața List are de asemenea metoda contains care efectuează

această sarcină și care returnează o valoare de tip boolean:

System.out.println(myList.contains("name"));

Putem converti o listă într-un șir în orice moment.

Manual:

© Copyright Link group 7 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

String[] arr = new String[myList.size()];

for(int i=0;i<myList.size();i++)

arr[i]=myList.get(i);

Sau cu metoda toArray:

String[] arr = myList.toArray(new String[myList.size()]);

Ștergerea unei liste se face cu metoda clear.

myList.clear();

Trebuie ținut cont că ArrayList funcționează astfel încât conține șirul cu

care manipulează în cadrul clasei. Acesta este motivul pentru care
accesarea elementelor sale este foarte rapidă, însă manipularea este
oarecum mai lentă.

Map

Mai există un tip comun de colecție în Java. Este vorba despre un șir de
perechi de chei și valori, respectiv un șir asociativ. Clasele care permit
utilizarea acestor colecții în Java moștenesc interfața Map. Într-o astfel
de structură, elementele șirului sunt identificate prin intermediul unei
anumite chei care le reprezintă. De exemplu, într-o colecție de
cetățeni, codul numeric personal este cheia, în timp ce datele (nume,
prenume, adresă) reprezintă valoarea pentru fiecare cetățean. Dacă

© Copyright Link group 8 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

am dori să găsim un anumit cetățean, este suficient să-i cunoaștem

codul numeric personal, respectiv cheia. Cea mai des utilizată clasă a
acestui tip este HashMap.

Haideți să vedem utilizarea acestei clase într-un exemplu.

HashMap hashMap = new HashMap();

După instanțierea clasei hashMap, adăugăm perechile cu metoda put:

hashMap.put("1234567890123", "John Davidson");

hashMap.put("1234567890124", "Tom Dvorak");

Valoarea care stă lângă cheie o obținem cu metoda get:

System.out.println(hashMap.get("1234567890124"));

Regula generală este că un șir de perechi de chei și valori conține

numai chei unice. În cazul clasei HashMap, introducerea acelorași chei
nu va cauza o eroare, ci, în timpul căutării, sub cheie se va afla ultima
cheie adăugată (vechea cheie va fi suprascrisă).

De exemplu:

myHash.put("1234567890123", "John Davidson");

myHash.put("1234567890124", "Mia Parkinson");
myHash.put("1234567890124", "Tom Dvorak");

Acest cod nu va raporta o eroare, însă după o astfel de implementare,

obiectul HashMap va avea doar 2 elemente, iar valoarea Tom Dvorak
va fi singura sub cheia 1234567890124.

Mai multe din cadrul acestei lecții

Crearea individuală a unei clase de colecții.

În exemplul următor, vom arăta logica din spatele creării unei colecții.

© Copyright Link group 9 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

Cu alte cuvinte, vă vom arăta modul în care puteți crea dvs. înșivă o
clasă ce va reprezenta o colecție. Haideți să creăm mai întâi o clasă ce
va reprezenta elementele unei liste simple înlănțuită:

public class Node {

public Node(int value)
{
this.value = value;
}
public int value;
public Node nextNode;
}

De asemenea, există o structură care gestionează colecţia şi care este

alcătuită din elemente de tip Node. Această structură (clasă) se
numeşte NodeList. Această clasă are două proprietăţi: actualNode şi
Head. Head este proprietatea care va stoca datele despre primul
element al listeu, în timp ce actualNode reprezintă locaţia unde se află
în prezent maker-ul listei. De asemenea, clasa conţine două metode
(deşi poate avea mult mai multe).

public class NodeList {

public Node actualNode;
public Node head;
public void add(int value)
{
if(head==null)
{
head=new Node(value);
actualNode=head;
return;
}
actualNode=head;
while(actualNode.nextNode!=null)
actualNode=actualNode.nextNode;
actualNode.nextNode=new Node(value);
}

© Copyright Link group 10 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

public int getValue(int pos)

{
int counter = 0;
actualNode=head;
while(actualNode.nextNode!=null)
{
if(counter==pos)
break;
actualNode = actualNode.nextNode;
counter++;
}
return actualNode.value;
}
}

Prima metodă, add, adaugă o valoare în listă. Putem vedea că

adăugarea valorilor este simplă dacă lista este goală, respectiv dacă
head Node are valoarea null. În acest caz, noi creăm un nou obiect
Node, îl setăm ca actual şi părăsim metoda. Dacă head nu este null,
înseamnă că există deja o listă şi setăm următorul Node (de la Node-ul
curent) ca actual, de fiecare dată când trecem prin această listă. Când
următorul Node de la Node-ul curent este null, se va genera un nou
Node pe acea poziţie, iar lista cu Node-uri va creşte.

În timpul căutării Node-urilor (metoda getValue), trecem prin Node-uri

în acelaşi mod, de la "cap" la "coadă", iar dacă numărătorul se
potriveşte cu indexul dorit în timpul trecerii, metoda se va opri şi va
returna valoarea.

Iată cum arată utilizarea clasei NodeList:

NodeList list = new NodeList();

list.add(1);
list.add(5);
list.add(10);
System.out.println(list.getValue(2));

© Copyright Link group 11 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

În exemplul anterior, putem vedea logica de fundal a listei. Lista are

metodele getValue şi add. Pentru ca această listă să se potrivească cu
listele integrate ale Java Framework, trebuie să implementăm interfaţa
necesară. Aceasta este interfaţa List. Conţine câteva semnături de
metodă cu denumiri intuitive, ce ne permit să gestionăm o listă (size,
isEmpty, Contains, Iterator, toArray, Add, Remove, containsAll, addAll,
addAll, removeAll, retainAll, Clear, Get, Set, Add, Remove, indexOf,
lastIndexOf, listIterator, listIterator şi subList). Dacă am dori să creăm o
colecţie de utilizator la fel ca în exemplul de mai sus, trebuie să
asigurăm implementarea pentru toate aceste metode.

În cele din urmă, există clase integrate în Collection Framework ce

implementează această interfaţă (sau altele pe care le-am menţionat)
şi care conţin o logică similară cu cea din exemplul nostru. Aceste
clase sunt considerate colecţii.

Exerciții

Exercițiul 1

Avem o clasă User:

public class User {

public int Id;
public String name;
public User(int id, String name)
{
this.Id = id;
this.name = name;
}
}

© Copyright Link group 12 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

De asemenea, în metoda Main a aplicației, avem următorul cod:

...

ArrayList usersToAdd = new ArrayList();

usersToAdd.add(new User(4,"Goran"));
usersToAdd.add(new User(2,"Ilija"));
usersToAdd.add(new User(6,"Nikola"));

ArrayList users = new ArrayList ();

users.add(new User(1, "Petar"));
users.add(new User(2, "Jovan"));
users.add(new User(3, "Zoran"));

...

Adăugați toți utilizatorii din lista usersToAdd în lista Users. Dacă există
deja un utilizator cu același ID, înlocuiți vechiul utilizator cu cel nou.

Afișați lista Users.

Soluția 1:

Soluţia subînţelege trecerea printr-un şir de elemente care sunt

adăugate şi, în cadrul fiecărei treceri, se trece printr-un şir de elemente
care există deja. Dacă în şirul cu elementele existente se află un
element ce are ID-ul elementului curent care este adăugat, respectivul
utilizator este înlocuit cu cel nou:

...

for(int i=0;i<usersToAdd.size();i++)
{
boolean userExists = false;
for(int u=0;u<users.size();u++)
{

© Copyright Link group 13 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

if(((User)users.get(u)).Id==((User)usersToAdd.get(i)).Id)
{
users.set(u, (User)usersToAdd.get(i));
userExists=true;
}
}
if(!userExists)
users.add(usersToAdd.get(i));
else
userExists=false;
}

for(Object u : users)
System.out.println(((User) u).Id + ":" + ((User) u).name);
}

...

Soluția 2:

În această soluţie, trecând prin lista de utilizatori existenţi, determinăm

dacă există un ID care se potriveşte în lista de utilizatori care se
adaugă. Dacă există, acest utilizator este şters din lista de utilizatori
existenţi. În cele din urmă, când toţi utilizatorii sunt şterşi, vom utiliza
metoda addAll pentru a adăuga lista completă de utilizatori noi în lista
cu utilizatori existenţi.

for(int i=0;i<users.size();i++)
{
for(int u=0;u<usersToAdd.size();u++)
{
if(((User)users.get(i)).Id==((User)usersToAdd.get(u)).Id)
users.remove(u);
}
}

© Copyright Link group 14 / 16

Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

users.addAll(usersToAdd);

for (Object u : users)

System.out.println(((User) u).Id + ":" + ((User) u).name);

Exercițiul 2

Pe baza clasei User existente (din exercițiul anterior), am creat

următoarea listă.

ArrayList users = new ArrayList();

users.add(new User(4,"Goran"));
users.add(new User(2,"Ilija"));
users.add(new User(6,"Nikola"));
users.add(new User(1, "Petar"));
users.add(new User(2, "Jovan"));
users.add(new User(3, "Zoran"));

Se poate adăuga că lista poate fi creată şi sub forma:

ArrayList <User> users = new ArrayList<User>();

sau utilzând operatorul diamond introdus în JDK7, se poate crea astfel:

ArrayList <User> users = new ArrayList<>();

Oniect users poate fi declarat şi cu tipul List, clasa ArrayList

implementând interfaţa List:
List <User> users = new ArrayList<>();

Sortați utilizatorii în funcție de ID și afișați lista la ieșire.

Soluția:

...
int min;

© Copyright Link group 15 / 16

 Curs: Core Java Programming
Module: Tipurile de date obiectuale
Unitate: Colecțiile

User tmp;
for (int i = 0; i < users.size(); i++) {
min = i;
for (int u = i; u < users.size(); u++) {
if (((User) users.get(u)).Id < ((User) users.get(min)).Id) {
min = u;
}
}
tmp = (User) users.get(min);
users.set(min, (User) users.get(i));
users.set(i, tmp);
}

for (Object u : users) {

System.out.println(((User) u).Id + ":" + ((User) u).name);
}
...

© Copyright Link group 16 / 16

Powered by TCPDF (www.tcpdf.org)