"Hej, Amigo!"
"Hej, Ellie!"
"I dag vil vi vikle vores hoveder omkring strukturen af samlinger én gang for alle."
"Jeg har ventet længe på det her."
"Du ved allerede, hvad samlinger er, og du ved, hvordan du arbejder med dem. Det er på tide at organisere din viden i et stramt system. Så forsvinder mange 'hvorfor' og 'hvordan'-spørgsmål, og det meste bliver åbenlyst."
" Samlingsgrænseflader . Arvestrukturen af samlingsgrænseflader ser nogenlunde sådan ud:"
Læg mærke til to ting.
For det første er alt, hvad du ser her en grænseflade.
For det andet betyder pilene «arver».
"Med andre ord, List, Set og Queue arver samling, men Map gør det ikke?"
"Jep. Abstrakte klasser arver så disse grænseflader, og til gengæld arver de implementeringer, du kender til disse abstrakte klasser: ArrayList, Hashtable, TreeSet,... "
"Du har ret."
"Lad os nu se, hvad disse interfaces' metoder er til:"
Metoder til Iterable<E>: -grænsefladen:
| Metoder | Beskrivelse |
|---|---|
Iterator<T> iterator(); |
Returnerer et iteratorobjekt. |
"Det virker ikke som nok."
"Nå, det er så mange, der er. Det er alt for iteratorer. Vi vil ikke dække dem lige nu, men vi vil dække dem i detaljer snart."
Indsamlingsmetoder <E>: interface:
| Metoder | Beskrivelse |
|---|---|
boolean add(E e); |
Tilføjer et element til samlingen |
boolean addAll(Collection<? extends E> c); |
Tilføjer elementer til samlingen |
void clear(); |
Fjerner alle elementer fra samlingen |
boolean contains(Object o); |
Kontrollerer, om samlingen indeholder elementet. |
boolean containsAll(Collection<?> c); |
Kontrollerer, om samlingen indeholder elementerne. |
boolean equals(Object o); |
Kontrollerer, om samlinger er ækvivalente |
int hashCode(); |
Returnerer hash-koden |
boolean isEmpty(); |
Kontrollerer, om samlingen er tom. |
Iterator<E> iterator(); |
Returnerer et iteratorobjekt |
boolean remove(Object o); |
Fjerner et element fra samlingen |
boolean removeAll(Collection<?> c); |
Fjerner elementer fra samlingen |
boolean retainAll(Collection<?> c); |
Fjerner alle elementer, der ikke er i c |
int size(); |
Returnerer samlingens størrelse |
Object[] toArray(); |
Konverterer samlingen til en matrix |
<T> T[] toArray(T[] a); |
Konverterer samlingen til en matrix |
"Jeg er allerede solid på alt her. Jeg har brugt halvdelen af disse metoder, og jeg er stødt på den anden halvdel."
"Godt, lad os fortsætte så."
Metoder til listen<E>: interface:
| Metoder | Beskrivelse |
|---|---|
void add(int index, E element); |
Tilføjer elementer til midten af samlingen |
boolean addAll(int index, Collection<? extends E> c); |
Tilføjer elementer til samlingen |
E get(int index); |
Returnerer et element efter indeks |
int indexOf(Object o); |
Returnerer indekset (tallet) for et element |
int lastIndexOf(Object o); |
Returnerer indekset for det sidste element. |
ListIterator<E> listIterator(); |
Returnerer en iterator for listen |
ListIterator<E> listIterator(int index); |
Returnerer en iterator for listen |
E remove(int index); |
Fjerner et element efter dets indeks |
E set(int index, E element); |
Indstiller en ny værdi efter indeks |
List<E> subList(int fromIndex, int toIndex); |
Returnerer en undersamling |
"Her er der heller ikke noget radikalt nyt. Jeg ved i forvejen næsten alt om kollektioner, hvilket jeg ikke kan lade være med at være glad for."
"Nå, jeg tror, jeg kan finde noget, der vil overraske dig. Men lad os fortsætte med at undersøge grænseflader:"
Metoder for sættet<E>: interface:
| Metoder | Beskrivelse |
|---|---|
|
|
|
"Set-grænsefladen har ingen nye metoder - kun dem, den arver."
"Ja, jeg så, at Interable-grænsefladen heller ikke havde noget.
"På den anden side betyder færre metoder mindre at huske!"
"Din livsbekræftende optimisme gør mig glad."
"Set-grænsefladen er nedarvet af to grænseflader med metoder: SortedSet og NavigableSet. Men jeg vil ikke gennemgå dem, ellers bliver vi aldrig færdige."
"Lad mig i stedet give dig et generelt billede af de klasser og grænseflader, der beskriver samlinger i Java."
"Kom med det."
"Så hold fast:"
"Wow, det er stort!"
"Nå, det er ikke så stort. Husk også, at abstrakte klasser er helt valgfrie. Men det er godt at huske, hvilken klasse der implementerer hvilke grænseflader. Det kan være nyttigt ret ofte."
"Åh, jeg vil også gerne bemærke, at nogle samlinger betragtes som forældede."
"Hvilke er det?"
"Jeg taler om klasserne Vector, Stack, Dictionary og Hashtable. Disse er synkroniserede (trådsikre) versioner af almindelige samlinger."
"Men Java har tilføjet et særligt samtidighedsbibliotek med en masse samlinger, som ikke kun kan tilgås fra andre tråde, men som også har en meget mere effektiv implementering. ConcurrentHashMap er meget mere effektiv end Hashtable ."
"Du kan bruge samlingerne Vector, Stack, Dictionary og Hashtable, men det anbefales ikke."
"Godt, det vil jeg huske på."
"Tak, Ellie!"
GO TO FULL VERSION