Course Java Collections - Lecture: Collectie-interfaces

"Hallo Amigo!"

"Hallo, Ellie!"

"Vandaag gaan we ons voor eens en voor altijd bezighouden met de structuur van collecties."

"Hier heb ik lang op gewacht."

"Je weet al wat collecties zijn, en je weet hoe je ermee moet werken. Het wordt tijd om je kennis in een strikt systeem te ordenen. Dan zullen veel 'waarom'- en 'hoe'-vragen verdwijnen en zullen de meeste dingen voor de hand liggen."

" Collectie-interfaces . De overervingsstructuur van collectie- interfaces ziet er ongeveer zo uit:"

Let op twee dingen.

Ten eerste is alles wat je hier ziet een interface.

Ten tweede betekenen de pijlen «erft».

"Met andere woorden, Lijst, Set en Wachtrij erven Verzameling, maar Kaart niet?"

"Ja. Abstracte klassen erven dan deze interfaces en op hun beurt erven de implementaties die je kent die abstracte klassen: ArrayList, Hashtable, TreeSet,... "

"Je hebt gelijk."

"Laten we nu eens kijken waar de methoden van deze interfaces voor zijn:"

Methoden van de Iterable<E>: -interface:

methoden	Beschrijving
`Iterator<T> iterator();`	Retourneert een iteratorobject.

"Dat lijkt niet genoeg."

"Nou, dat zijn er zoveel. Dat is alles voor iterators. We zullen ze nu niet behandelen, maar we zullen ze binnenkort in detail behandelen."

Methoden van de collectie<E>: interface:

methoden	Beschrijving
`boolean add(E e);`	Voegt een element toe aan de verzameling
`boolean addAll(Collection<? extends E> c);`	Voegt elementen toe aan de collectie
`void clear();`	Verwijdert alle elementen uit de collectie
`boolean contains(Object o);`	Controleert of de verzameling het element bevat.
`boolean containsAll(Collection<?> c);`	Controleert of de collectie de elementen bevat.
`boolean equals(Object o);`	Controleert of verzamelingen gelijkwaardig zijn
`int hashCode();`	Retourneert de hash-code
`boolean isEmpty();`	Controleert of de verzameling leeg is.
`Iterator<E> iterator();`	Retourneert een iteratorobject
`boolean remove(Object o);`	Verwijdert een element uit de verzameling
`boolean removeAll(Collection<?> c);`	Verwijdert elementen uit de verzameling
`boolean retainAll(Collection<?> c);`	Verwijdert alle elementen die niet in c staan
`int size();`	Retourneert de grootte van de collectie
`Object[] toArray();`	Converteert de verzameling naar een array
`<T> T[] toArray(T[] a);`	Converteert de verzameling naar een array

"Ik ben hier al goed in alles. Ik heb de helft van deze methoden gebruikt en de andere helft ben ik tegengekomen."

"Mooi, dan gaan we verder."

Methoden van de Lijst<E>: interface:

methoden	Beschrijving
`void add(int index, E element);`	Voegt elementen toe aan het midden van de collectie
`boolean addAll(int index, Collection<? extends E> c);`	Voegt elementen toe aan de collectie
`E get(int index);`	Retourneert een element per index
`int indexOf(Object o);`	Retourneert de index (nummer) van een element
`int lastIndexOf(Object o);`	Retourneert de index van het laatste element.
`ListIterator<E> listIterator();`	Retourneert een iterator voor de lijst
`ListIterator<E> listIterator(int index);`	Retourneert een iterator voor de lijst
`E remove(int index);`	Verwijdert een element op basis van zijn index
`E set(int index, E element);`	Stelt een nieuwe waarde in per index
`List<E> subList(int fromIndex, int toIndex);`	Retourneert een subcollectie

"Ook hier niets radicaal nieuws. Ik weet al bijna alles van collecties, waar ik alleen maar blij mee kan zijn."

"Nou, ik denk dat ik iets kan vinden dat je zal verrassen. Maar laten we doorgaan met het onderzoeken van interfaces:"

Methoden van de Set<E>: -interface:

methoden	Beschrijving
Geen methodes

"De Set-interface heeft geen nieuwe methoden - alleen die welke het overerft."

"Ja, ik zag dat de Interable-interface ook niets had.

"Aan de andere kant betekent minder methoden minder om te onthouden!"

"Je levensbevestigende optimisme maakt me blij."

"De Set-interface wordt geërfd door twee interfaces met methoden: SortedSet en NavigableSet. Maar ik zal ze niet bespreken, anders komen we nooit af."

"Laat me je in plaats daarvan een algemeen beeld geven van de klassen en interfaces die collecties in Java beschrijven."

"Kom maar op."

"Hou je dan goed vast:"

"Wauw, dat is enorm!"

"Nou, het is niet zo groot. Onthoud ook dat abstracte klassen volledig optioneel zijn. Maar het is goed om te onthouden welke klasse welke interfaces implementeert. Dat kan vrij vaak van pas komen."

"Oh, ik zou ook willen opmerken dat sommige collecties als verouderd worden beschouwd."

"Welke zijn dat?"

"Ik heb het over de klassen Vector, Stack, Dictionary en Hashtable. Dit zijn gesynchroniseerde (thread-safe) versies van gewone collecties."

"Maar Java heeft een speciale concurrency- bibliotheek toegevoegd met veel collecties die niet alleen toegankelijk zijn vanuit andere threads, maar ook een veel efficiëntere implementatie hebben. ConcurrentHashMap is veel efficiënter dan Hashtable ."

"Je kunt de collecties Vector, Stack, Dictionary en Hashtable gebruiken, maar dat wordt niet aanbevolen."

"Begrepen, ik zal het in gedachten houden."

"Bedankt, Ellie!"