1. Structuri de Date în Java (VI)
Interfaţa Map
Metodele caracteristice ale Map
Pericolele modificării cheilor
Prevenirea alterării cheii:
Modificarea copiei
Chei nemodificabile
Proxy-uri nemodificabile pentru chei
Îngheţarea cheilor
Comparare şi sortare
Interfaţa Comparable
Interfaţa Comparator
Set-uri sortate
Stive. Cozi

2. Interfaţa Map
Realizează maparea între un set de chei şi un set de valori – perechi de tip (key, value)
Pentru fiecare obiect cheie avem un obiect valoare corespondent
Este în esenţă un instrument de tip “lookup”
Cheile trebuie să fie unice, însă valorile nu

3. Atenţie: Map nu este o Collection
Map nu suportă:
boolean add (Ceva c);
boolean contains (Object obj);
Însă suportă:
boolean put (TipCheie key, TipValue val);
boolean containsKey (TipCheie key);
boolean containsValue (TipValue val);

4. Exemplu de folosire a lui Map
Map<String, String> dns = new HashMap<String, String> ();
dns.put ("vega.unitbv.ro", " ");
System.out.println (dns.get ("vega.unitbv.ro"));
System.out.println (dns.containsKey ("vega.unitbv.ro"));
System.out.println (dns.containsValue (" "));
dns.remove ("vega.unitbv.ro");
// “ ”, true, true, false

5. Alte metode utile keySet() - returnează un Set cu toate cheile
values() - returnează o Collection cu toate valorile
entrySet() - returneză un set de perechi (key,value)
fiecare pereche este un obiect Map.Entry
Map.Entry suportă getKey, getValue, setValue
orice schimbare în Map se reflectă în Set

6. Pericolele modificării cheilor
O cheie trebuie să rămână egală cu ceea ce a fost înainte (în sensul metodei equals)
Seamănă cu situaţia de la Set-uri
Dacă o cheie se schimbă, ea împreună cu valoarea asociată vor fi “pierdute”

7. Folosire incorectă Name daniela = new Name ("Daniela", "Corboteanu");
Map<Name, String> catalog = new HashMap<Name, String> ();
catalog.put (daniela, " ");
System.out.println (catalog.get (daniela));
daniela.first = "Ionel";
catalog.put (new Name ("Daniela", "Corboteanu"), " ");
daniela.first = "Daniela";

8. Două răspunsuri Răspunsul corect: // 0740-123-456, null, 0740-555-123
Răspunsul şi mai corect:
Nu contează pentru că nu ar trebui să facem acest lucru
Comportare impredictiblă

9. Cum să prevenim modificarea cheii?
Dorim să putem modifica un obiect din Map
Dar obiectele cu chei modificabile sunt periculoase

10. Copierea cheii Name daniela = new Name (“Daniela”, “Corboteanu”);
Name copy = new Name (daniela.first, daniela.last);
map.put (copy, “ ”);
Acum schimbările în obiectul daniela nu zăpăcesc map-ul
Dar cheile în sine tot pot fi modificate:
for (Name name : map.keySet ()) {
name.first = “ am buşit cheia”; // n-am rezolvat nimic }

11. Facem cheile nemodificabile
public class Name {
public final String first;
public final String last;
public Name (String first, String last) {
this.first = first;
this.last = last; }
public boolean equals (Object o) {
return (o instanceof Name &&
((Name) o).first.equals (this.first) &&
((Name) o).last.equals (this.last));

12. Proxy-uri nemodificabile pentru chei
Map<String, String> dir = new HashMap<String, String> ();
Name daniela = new Name (“Daniela”, “Corboteanu”);
String key = daniela.first + “,” + daniela.last;
catalog.put (key, “ ”);
String-urile sunt nemodificabile, deci Map-ul va fi protejat

13. Noţiunea de proxy
“Un proxy, în forma sa cea mai generală, este o clasă funcţionînd ca o interfaţă către altceva. Acel altceva poate fi orice: o conexiune de reţea, un obiect de dimensiune mare în memorie, un fişier sau orice altă resursă care este scumpă de folosit sau imposibil de duplicat.”
(Wikipedia)

14. “Îngheţarea” cheilor public class Name {
private String first; // nemodificabile din afara clasei
private String last;
private boolean frozen = false;
// …
public void setFirst (String s) { // metodă mutator controlabilă
if (!frozen) first = s; }
// … la fel pentru setLast
public void freeze () {
frozen = true;

15. Rezumat: modificarea cheilor
Fiecare abordare vine cu anumite dezavantaje
Pentru fiecare situaţie alegem abordarea cea mai simplă şi mai la îndemână pe principiul că ce e simpu, bine structurat, e previzibil şi deci uşor de depanat
Dacă o cheie nu poate fi niciodată modificată, atunci nu vom avea niciodată probleme cu ea
Nu scrieţi o implementare pe care nu o înţelegeţi deplin decât ca un ultim refugiu
Dacă ni se pare complicat de scris înseamnă că nu ne-am gândit îndeajuns de mult la problemă

16. Comparare şi sortare
Folosite pentru a decide, între două obiecte, dacă unul este mai mare decât celălalt
(a.compareTo (b)) trebuie să genereze:
< 0 dacă a < b
= 0 dacă a = b
> 0 dacă a > b

17. Exemplu de comparare Integer one = 1;
System.out.println (one.compareTo (3));
System.out.println (one.compareTo (-50));
String frank = “Frank”;
System.out.println (frank.compareTo (“Booth”));
System.out.println (frank.compareTo (“Hopper”));
// -1, 1, 4, -2

18. Sortarea alfabetică
List<String> names = new ArrayList<String> ();
names.add (“Sailor”);
names.add (“Lula”);
names.add (“Bobby”);
names.add (“Santos”);
names.add (“Dell”);
Collections.sort (names);
// names: [ “Bobby”, “Dell”, “Lula”, “Sailor”, “Santos” ]

19. Interfaţa Comparable
Putem compara String-uri pentru că ele implementează interfaţa Comparable
Altfel spus, String-urile definesc o “ordine naturală”
Pentru a face clasa Ceva comparabilă, trebuie să implementăm:
int compareTo (Ceva c);

20. Name-urile devin comparabile
public class Name implements Comparable<Name> {
// …
public int compareTo (Name o) {
int compare = this.last.compareTo (o.last);
if (compare != 0)
return compare;
else
return this.first.compareTo (o.first); }

21. Exemplu de listă sortată de Name-uri
List<Name> names = new ArrayList<Name> ();
names.add (new Name ("Nicolas", "Cage"));
names.add (new Name ("Laura", "Dern"));
names.add (new Name ("Harry", "Stanton"));
names.add (new Name ("Diane", "Ladd"));
names.add (new Name ("William", "Morgan"));
names.add (new Name (“Dirty”, "Glover"));
System.out.println (names);
Collections.sort (names);
// [ Nicolas Cage, Laura Dern, Dirty Glover, Diane Ladd,
// William Morgan, Harry Stanton ]

22. Interfaţa Comparator
Pentru a crea mai multe ordini de sortare pentru un anumit tip, vom defini clase Comparator
Un Comparator primeşte două obiecte şi decide care este mai mare
Pentru tipul Ceva, un Comparator<Ceva> are:
int compare (Ceva o1, Ceva o2);

23. Un Comparator după prenume
public class FirstNameFirst implements Comparator<Name> {
public int compare (Name n1, Name n2) {
int ret = n1.first.compareTo (n2.first);
if (ret != 0)
return ret;
else
return n1.last.compareTo (n2.last); }
Atenţie, compararea se face altfel decât în cazul Comparable

24. Exemplu de Comparator
List<Name> names = new ArrayList<Name> ();
// ..
Comparator<Name> first = new FirstNameFirst ();
Collections.sort (names, first);
System.out.println (names);
// [ Diane Ladd, Dirty Glover, Harry Stanton, Laura Dern, // Nicolas Cage, William Morgan ]
Sortarea se face folosind comparatorul tocmai creat

25. Seturi sortate TreeSet – o colecţie de obiecte menţinută mereu sortată
Fie Object-urile din TreeSet trebuie să implementeze Comparable
Sau se furnizează un obiect Comparator la crearea lui TreeSet
SortedSet<Name> names = new TreeSet<Name> (new FirstNameFirst ());
names.add (new Name ("Laura", "Dern"));
names.add (new Name ("Harry", "Stanton"));
names.add (new Name ("Diane", "Ladd"));
System.out.println(names);
// [ Diane Ladd, Harry Stanton, Laura Dern]

26. Stivă (stack)
Structură de date bazată pe principiul LIFO (Last In First Out), în care accesul la elemente se face numai pe la un singur capăt denumit vârf
Se scoate întotdeauna
elementul de deasupra
Se pune peste elementul
de deasupra

27. Clasa Stack Implementează interfaţa Collection
Metodele clasei Stack<E>:
boolean empty ()
E peek () - inspectează fără ştergere
E pop () - scoatere cu ştergere
E push (E e) - introducere
int search (Object o) – adâncimea lui o în stivă
Se aruncă EmptyStackException dacă se face pop sau peek pe o stivă goală

28. O propoziţie întoarsă pe dos
String line = new String ("epurasul usa rupe");
Stack<Character> sc = new Stack<Character> ();
for (int i = 0 ; i < line.length () ; i ++)
sc.push (line.charAt (i));
String reverse = new String ();
while (sc.size () > 0)
reverse += sc.pop ();
System.out.println (reverse);
// “epur asu lusarupe”

29. Coadă (queue)
O colecţie de elemente aşezate în ordine pentru care adăugarea se face întotdeauna la sfârşit iar extragerea se face de la început
Principiul FIFO
(First In
First Out)
remove
add

30. Clasa LinkedList Implementează interfeţele Collection şi Queue
Metodele interfeţei Queue<E>:
boolean add (E e) – adăugare la sfârşit
E element () - inspecarea începutului
boolean offer (E e) – adăugare fără aruncare excepţie
E peek () - inspectare fără aruncare excepţie
E poll () - obţinerea capătului, fără aruncare excepţie
E remove () - ştergerea capătului
Se aruncă NoSuchElementException dacă coada este goală şi se încearcă extragerea unui element din ea (element, peek, remove)

31. Un palindrom String line = "copac";
Stack<Character> sc = new Stack<Character> ();
LinkedList<Character> llc = new LinkedList<Character> ();
for (int i = 0 ; i < line.length () ; i ++) {
sc.push (line.charAt (i));
llc.add (line.charAt(i)); }
String palindrom = new String ();
while (llc.size() > 0)
palindrom += llc.remove ();
while (sc.size () > 0)
palindrom += sc.pop ();
System.out.println (palindrom);
// “copaccapoc”