Course Java-samlingar - Lecture: Samlingsgränssnitt

"Hej, Amigo!"

"Hej Ellie!"

"I dag ska vi linda våra huvuden runt samlingarnas struktur en gång för alla."

"Jag har väntat länge på det här."

"Du vet redan vad samlingar är, och du vet hur du arbetar med dem. Det är dags att organisera dina kunskaper i ett strikt system. Då försvinner många "varför" och "hur"-frågor, och det mesta blir uppenbart."

" Samlingsgränssnitt . Arvsstrukturen för samlingsgränssnitt ser ut ungefär så här:"

Lägg märke till två saker.

För det första är allt du ser här ett gränssnitt.

För det andra betyder pilarna "ärver".

"Med andra ord, List, Set och Queue ärver samlingen, men Map inte?"

"Japp. Abstrakta klasser ärver sedan dessa gränssnitt och i sin tur ärver de implementeringar du känner till dessa abstrakta klasser: ArrayList, Hashtable, TreeSet,... "

"Du har rätt."

"Låt oss nu se vad dessa gränssnitts metoder är till för:"

Metoder för Iterable<E>: -gränssnittet:

Metoder	Beskrivning
`Iterator<T> iterator();`	Returnerar ett iteratorobjekt.

"Det verkar inte vara tillräckligt."

"Tja, det är så många det finns. Det är allt för iteratorer. Vi kommer inte att täcka dem just nu, men vi kommer att täcka dem i detalj snart."

Metoder för samlingen<E>: gränssnitt:

Metoder	Beskrivning
`boolean add(E e);`	Lägger till ett element i samlingen
`boolean addAll(Collection<? extends E> c);`	Lägger till element i samlingen
`void clear();`	Tar bort alla element från samlingen
`boolean contains(Object o);`	Kontrollerar om samlingen innehåller elementet.
`boolean containsAll(Collection<?> c);`	Kontrollerar om samlingen innehåller elementen.
`boolean equals(Object o);`	Kontrollerar om samlingarna är likvärdiga
`int hashCode();`	Returnerar hashkoden
`boolean isEmpty();`	Kontrollerar om samlingen är tom.
`Iterator<E> iterator();`	Returnerar ett iteratorobjekt
`boolean remove(Object o);`	Tar bort ett element från samlingen
`boolean removeAll(Collection<?> c);`	Tar bort element från samlingen
`boolean retainAll(Collection<?> c);`	Tar bort alla element som inte finns i c
`int size();`	Returnerar samlingens storlek
`Object[] toArray();`	Konverterar samlingen till en array
`<T> T[] toArray(T[] a);`	Konverterar samlingen till en array

"Jag är redan solid på allt här. Jag har använt hälften av dessa metoder, och jag har stött på den andra hälften."

"Bra, låt oss fortsätta då."

Metoder för listan<E>: gränssnitt:

Metoder	Beskrivning
`void add(int index, E element);`	Lägger till element i mitten av samlingen
`boolean addAll(int index, Collection<? extends E> c);`	Lägger till element i samlingen
`E get(int index);`	Returnerar ett element efter index
`int indexOf(Object o);`	Returnerar indexet (talet) för ett element
`int lastIndexOf(Object o);`	Returnerar indexet för det sista elementet.
`ListIterator<E> listIterator();`	Returnerar en iterator för listan
`ListIterator<E> listIterator(int index);`	Returnerar en iterator för listan
`E remove(int index);`	Tar bort ett element genom dess index
`E set(int index, E element);`	Ställer in ett nytt värde efter index
`List<E> subList(int fromIndex, int toIndex);`	Returnerar en undersamling

"Inget radikalt nytt här heller. Jag kan redan nästan allt om kollektioner, vilket jag inte kan annat än vara glad över."

"Tja, jag tror att jag kan hitta något som kommer att överraska dig. Men låt oss fortsätta att undersöka gränssnitt:"

Metoder för Set<E>: gränssnitt:

Metoder	Beskrivning
Inga metoder

"Set-gränssnittet har inga nya metoder - bara de som det ärver."

"Ja, jag såg att Interable-gränssnittet inte heller hade någonting.

"Å andra sidan betyder färre metoder mindre att komma ihåg!"

"Din livsbejakande optimism gör mig glad."

"Set-gränssnittet ärvs av två gränssnitt med metoder: SortedSet och NavigableSet. Men jag kommer inte gå igenom dem, annars blir vi aldrig färdiga."

"Låt mig istället ge dig en allmän bild av de klasser och gränssnitt som beskriver samlingar i Java."

"Kom an."

"Så håll i dig:"

"Wow, det är enormt!"

"Tja, det är inte så stort. Kom också ihåg att abstrakta klasser är helt valfria. Men det är bra att komma ihåg vilken klass som implementerar vilka gränssnitt. Det kan komma till nytta ganska ofta."

"Åh, jag skulle också vilja notera att vissa samlingar anses vara föråldrade."

"Vilka är det?"

"Jag pratar om klasserna Vector, Stack, Dictionary och Hashtable. Dessa är synkroniserade (trådsäkra) versioner av vanliga samlingar."

"Men Java har lagt till ett speciellt samtidighetsbibliotek med många samlingar som inte bara kan nås från andra trådar, utan också har en mycket effektivare implementering. ConcurrentHashMap är mycket effektivare än Hashtable ."

"Du kan använda samlingarna Vector, Stack, Dictionary och Hashtable, men det rekommenderas inte."

"Förstår, jag ska ha det i åtanke."

"Tack, Ellie!"