„Hallo, Amigo!“
„Hallo, Ellie!“
„Heute werden wir uns ein für alle Mal mit der Struktur von Sammlungen befassen.“
„Darauf habe ich lange gewartet.“
„Sie wissen bereits, was Sammlungen sind, und Sie wissen, wie man mit ihnen arbeitet. Es ist an der Zeit, Ihr Wissen in einem strengen System zu organisieren. Dann werden viele „Warum“- und „Wie“-Fragen verschwinden und die meisten Dinge werden offensichtlich.“
„ Sammlungsschnittstellen . Die Vererbungsstruktur von Sammlungsschnittstellen sieht in etwa so aus:“
Beachten Sie zwei Dinge.
Erstens ist alles, was Sie hier sehen, eine Schnittstelle.
Zweitens bedeuten die Pfeile „erbt“.
„Mit anderen Worten: List, Set und Queue erben Collection, Map jedoch nicht?“
„Ja. Abstrakte Klassen erben dann diese Schnittstellen und wiederum die Implementierungen, die Sie kennen, erben diese abstrakten Klassen: ArrayList, Hashtable, TreeSet,… “
"Du hast Recht."
„Jetzt wollen wir sehen, wozu die Methoden dieser Schnittstellen dienen:“
Methoden der Iterable<E>: -Schnittstelle:
| Methoden | Beschreibung |
|---|---|
Iterator<T> iterator(); |
Gibt ein Iteratorobjekt zurück. |
„Das scheint nicht genug zu sein.“
„Nun, so viele gibt es. Das ist alles für Iteratoren. Wir werden sie jetzt nicht behandeln, aber wir werden sie bald im Detail behandeln.“
Methoden der Collection<E>: -Schnittstelle:
| Methoden | Beschreibung |
|---|---|
boolean add(E e); |
Fügt der Sammlung ein Element hinzu |
boolean addAll(Collection<? extends E> c); |
Fügt Elemente zur Sammlung hinzu |
void clear(); |
Entfernt alle Elemente aus der Sammlung |
boolean contains(Object o); |
Überprüft, ob die Sammlung das Element enthält. |
boolean containsAll(Collection<?> c); |
Überprüft, ob die Sammlung die Elemente enthält. |
boolean equals(Object o); |
Überprüft, ob Sammlungen gleichwertig sind |
int hashCode(); |
Gibt den Hash-Code zurück |
boolean isEmpty(); |
Überprüft, ob die Sammlung leer ist. |
Iterator<E> iterator(); |
Gibt ein Iteratorobjekt zurück |
boolean remove(Object o); |
Entfernt ein Element aus der Sammlung |
boolean removeAll(Collection<?> c); |
Entfernt Elemente aus der Sammlung |
boolean retainAll(Collection<?> c); |
Entfernt alle Elemente, die nicht in c enthalten sind |
int size(); |
Gibt die Größe der Sammlung zurück |
Object[] toArray(); |
Konvertiert die Sammlung in ein Array |
<T> T[] toArray(T[] a); |
Konvertiert die Sammlung in ein Array |
„Hier bin ich mir bereits in allem sicher. Ich habe die Hälfte dieser Methoden verwendet und bin auf die andere Hälfte gestoßen.“
„Super, dann lass uns weitermachen.“
Methoden der List<E>: -Schnittstelle:
| Methoden | Beschreibung |
|---|---|
void add(int index, E element); |
Fügt Elemente zur Mitte der Sammlung hinzu |
boolean addAll(int index, Collection<? extends E> c); |
Fügt Elemente zur Sammlung hinzu |
E get(int index); |
Gibt ein Element nach Index zurück |
int indexOf(Object o); |
Gibt den Index (Nummer) eines Elements zurück |
int lastIndexOf(Object o); |
Gibt den Index des letzten Elements zurück. |
ListIterator<E> listIterator(); |
Gibt einen Iterator für die Liste zurück |
ListIterator<E> listIterator(int index); |
Gibt einen Iterator für die Liste zurück |
E remove(int index); |
Entfernt ein Element anhand seines Index |
E set(int index, E element); |
Legt einen neuen Wert nach Index fest |
List<E> subList(int fromIndex, int toIndex); |
Gibt eine Untersammlung zurück |
„Auch hier nichts radikal Neues. Ich weiß bereits fast alles über Kollektionen, worüber ich mich nur freuen kann.“
„Nun, ich denke, ich kann etwas finden, das Sie überraschen wird. Aber lassen Sie uns die Schnittstellen weiter untersuchen:“
Methoden der Set<E>: -Schnittstelle:
| Methoden | Beschreibung |
|---|---|
|
|
|
„Die Set-Schnittstelle hat keine neuen Methoden – nur die, die sie erbt.“
„Ja, ich habe gesehen, dass die Interable-Schnittstelle auch nichts hatte.
„Andererseits bedeuten weniger Methoden auch weniger Erinnerung!“
„Ihr lebensbejahender Optimismus macht mich glücklich.“
„Die Set-Schnittstelle wird von zwei Schnittstellen mit Methoden geerbt: SortedSet und NavigableSet. Aber ich werde nicht näher darauf eingehen, sonst werden wir nie fertig.“
„Stattdessen möchte ich Ihnen einen allgemeinen Überblick über die Klassen und Schnittstellen geben, die Sammlungen in Java beschreiben.“
"Her damit."
„Dann halte dich fest:“
„Wow, das ist riesig!“
„Nun, es ist nicht so groß. Denken Sie auch daran, dass abstrakte Klassen völlig optional sind. Es ist jedoch gut, sich daran zu erinnern, welche Klasse welche Schnittstellen implementiert. Das kann ziemlich oft nützlich sein.“
„Oh, ich möchte auch anmerken, dass einige Sammlungen als veraltet gelten.“
„Welche sind das?“
„Ich spreche von den Klassen Vector, Stack, Dictionary und Hashtable. Dabei handelt es sich um synchronisierte (threadsichere) Versionen gewöhnlicher Sammlungen.“
„Aber Java hat eine spezielle Parallelitätsbibliothek mit vielen Sammlungen hinzugefügt, auf die nicht nur von anderen Threads aus zugegriffen werden kann, sondern die auch eine viel effizientere Implementierung haben. ConcurrentHashMap ist viel effizienter als Hashtable .“
„Sie können die Sammlungen Vector, Stack, Dictionary und Hashtable verwenden, dies wird jedoch nicht empfohlen.“
„Verstanden, das werde ich mir merken.“
„Danke, Ellie!“
GO TO FULL VERSION