– Szia Amigo!
– Szia, Ellie!
"Ma egyszer s mindenkorra a gyűjtemények szerkezetére hajtjuk a fejünket."
– Sokáig vártam erre.
"Már tudja, mi a gyűjtemény, és tudja, hogyan kell velük dolgozni. Itt az ideje, hogy tudását szigorú rendszerbe rendezze. Akkor sok "miért" és "hogyan" kérdés eltűnik, és a legtöbb dolog nyilvánvalóvá válik."
" Gyűjtemény interfészek . A gyűjtőfelületek öröklődési struktúrája valahogy így néz ki:"
Két dolgot vegyél észre.
Először is, minden, amit itt lát, egy felület.
Másodszor, a nyilak azt jelentik, hogy „örököl”.
"Más szóval, a Lista, a Beállítás és a Várólista örökli a gyűjteményt, de a Térkép nem?"
"Igen. Az absztrakt osztályok öröklik ezeket az interfészeket, és az Ön által ismert implementációk öröklik ezeket az absztrakt osztályokat: ArrayList, Hashtable, TreeSet,… "
"Igazad van."
"Most lássuk, mire valók ezek az interfészek metódusai:"
Az Iterable<E>: interfész módszerei :
| Mód | Leírás |
|---|---|
Iterator<T> iterator(); |
Egy iterátor objektumot ad vissza. |
– Ez nem tűnik elégnek.
"Nos, ennyi van. Ennyi az iterátoroknak. Most nem foglalkozunk velük, de hamarosan részletesen is kitérünk rájuk."
A gyűjtés módszerei <E>: interfész:
| Mód | Leírás |
|---|---|
boolean add(E e); |
Hozzáad egy elemet a gyűjteményhez |
boolean addAll(Collection<? extends E> c); |
Elemeket ad a gyűjteményhez |
void clear(); |
Eltávolítja az összes elemet a gyűjteményből |
boolean contains(Object o); |
Ellenőrzi, hogy a gyűjtemény tartalmazza-e az elemet. |
boolean containsAll(Collection<?> c); |
Ellenőrzi, hogy a gyűjtemény tartalmazza-e az elemeket. |
boolean equals(Object o); |
Ellenőrzi, hogy a gyűjtemények egyenértékűek-e |
int hashCode(); |
Visszaadja a hash kódot |
boolean isEmpty(); |
Ellenőrzi, hogy a gyűjtemény üres-e. |
Iterator<E> iterator(); |
Egy iterátor objektumot ad vissza |
boolean remove(Object o); |
Eltávolít egy elemet a gyűjteményből |
boolean removeAll(Collection<?> c); |
Eltávolítja az elemeket a gyűjteményből |
boolean retainAll(Collection<?> c); |
Eltávolítja az összes olyan elemet, amely nem a c |
int size(); |
Visszaadja a gyűjtemény méretét |
Object[] toArray(); |
A gyűjteményt tömbbé alakítja |
<T> T[] toArray(T[] a); |
A gyűjteményt tömbbé alakítja |
"Itt már mindenben szilárd vagyok. Ezeknek a módszereknek a felét alkalmaztam, a másik felével pedig találkoztam."
– Remek, akkor folytassuk.
A Lista<E> módszerei : interfész:
| Mód | Leírás |
|---|---|
void add(int index, E element); |
Elemeket ad a gyűjtemény közepéhez |
boolean addAll(int index, Collection<? extends E> c); |
Elemeket ad a gyűjteményhez |
E get(int index); |
Egy elemet index szerint ad vissza |
int indexOf(Object o); |
Egy elem indexét (számát) adja vissza |
int lastIndexOf(Object o); |
Az utolsó elem indexét adja vissza. |
ListIterator<E> listIterator(); |
Egy iterátort ad vissza a listához |
ListIterator<E> listIterator(int index); |
Egy iterátort ad vissza a listához |
E remove(int index); |
Eltávolít egy elemet az indexe alapján |
E set(int index, E element); |
Új értéket állít be index szerint |
List<E> subList(int fromIndex, int toIndex); |
Egy algyűjteményt ad vissza |
"Itt sincs semmi gyökeresen új. Szinte mindent tudok már a kollekciókról, aminek nem tudok nem örülni."
"Nos, azt hiszem, találok valamit, ami meg fog lepni. De folytassuk a felületek vizsgálatát:"
A Set<E> metódusai : interfész:
| Mód | Leírás |
|---|---|
|
|
|
"A Set felület nem tartalmaz új metódusokat, csak azokat, amelyeket örököl."
"Igen, láttam, hogy az Interable felületen sem volt semmi.
– Másrészt a kevesebb módszer kevesebb emlékezést jelent!
– Az életigenlő optimizmusod boldoggá tesz.
"A Set felületet két metódusú interfész örökli: SortedSet és NavigableSet. De nem megyek át rajtuk, különben soha nem fejezzük be."
"Ehelyett hadd adjak egy általános képet a Java gyűjteményeket leíró osztályokról és felületekről."
– Hozd fel.
"Akkor kapaszkodj erősen:"
– Hú, ez óriási!
"Nos, ez nem olyan nagy. Ne feledje, hogy az absztrakt osztályok teljesen opcionálisak. De jó, ha megjegyezzük, hogy melyik osztály milyen interfészt valósít meg. Ez gyakran jól jöhet."
– Ó, azt is szeretném megjegyezni, hogy egyes gyűjtemények elavultnak számítanak.
– Melyek azok?
"A Vector, Stack, Dictionary és Hashtable osztályokról beszélek. Ezek a közönséges gyűjtemények szinkronizált (szálbiztos) változatai."
"A Java azonban hozzáadott egy speciális párhuzamossági könyvtárat sok gyűjteménnyel, amelyek nem csak más szálakból érhetők el, hanem sokkal hatékonyabb megvalósításuk is van. A ConcurrentHashMap sokkal hatékonyabb, mint a Hashtable ."
"Használhatja a Vector, Stack, Dictionary és Hashtable gyűjteményeket, de nem ajánlott."
– Értem, ezt észben tartom.
– Köszönöm, Ellie!
GO TO FULL VERSION