Course Mga Koleksyon ng Java - Lecture: Mga interface ng koleksyon

"Hi, Amigo!"

"Hi, Ellie!"

"Ngayon ay ipapaikot natin ang ating mga ulo sa istruktura ng mga koleksyon minsan at para sa lahat."

"Matagal kong hinintay ito."

"Alam mo na kung ano ang mga koleksyon, at alam mo kung paano magtrabaho kasama ang mga ito. Panahon na upang ayusin ang iyong kaalaman sa isang mahigpit na sistema. Pagkatapos ay maraming mga tanong na 'bakit' at 'paano' ang mawawala, at karamihan sa mga bagay ay magiging malinaw."

" Mga interface ng koleksyon . Mukhang ganito ang inheritance structure ng mga interface ng koleksyon :"

Pansinin ang dalawang bagay.

Una, lahat ng nakikita mo dito ay isang interface.

Pangalawa, ang mga arrow ay nangangahulugang "nagmana".

"Sa madaling salita, ang List, Set, at Queue ay nagmamana ng Koleksyon, ngunit ang Map ay hindi?"

"Oo. Ang mga abstract na klase ay minana ang mga interface na ito at, sa turn, ang mga pagpapatupad na alam mo tungkol sa namamana ng mga abstract na klase: ArrayList, Hashtable, TreeSet,… "

"Tama ka."

"Ngayon, tingnan natin kung para saan ang mga pamamaraan ng mga interface na ito:"

Mga Paraan ng Iterable<E>: interface:

Paraan	Paglalarawan
`Iterator<T> iterator();`	Nagbabalik ng iterator object.

"Mukhang hindi sapat iyon."

"Well, ang dami na. Yun lang para sa mga iterator. Hindi natin sila sasagutin sa ngayon, pero malapit na nating i-cover."

Mga Paraan ng Koleksyon<E>: interface:

Paraan	Paglalarawan
`boolean add(E e);`	Nagdaragdag ng elemento sa koleksyon
`boolean addAll(Collection<? extends E> c);`	Nagdaragdag ng mga elemento sa koleksyon
`void clear();`	Tinatanggal ang lahat ng elemento sa koleksyon
`boolean contains(Object o);`	Sinusuri upang makita kung naglalaman ang koleksyon ng elemento.
`boolean containsAll(Collection<?> c);`	Sinusuri upang makita kung ang koleksyon ay naglalaman ng mga elemento.
`boolean equals(Object o);`	Sinusuri upang makita kung ang mga koleksyon ay katumbas
`int hashCode();`	Ibinabalik ang hash code
`boolean isEmpty();`	Tinitingnan kung walang laman ang koleksyon.
`Iterator<E> iterator();`	Nagbabalik ng iterator object
`boolean remove(Object o);`	Nag-aalis ng elemento sa koleksyon
`boolean removeAll(Collection<?> c);`	Tinatanggal ang mga elemento mula sa koleksyon
`boolean retainAll(Collection<?> c);`	Tinatanggal ang lahat ng elementong wala sa c
`int size();`	Ibinabalik ang laki ng koleksyon
`Object[] toArray();`	Kino-convert ang koleksyon sa isang array
`<T> T[] toArray(T[] a);`	Kino-convert ang koleksyon sa isang array

"I'm already solid on everything here. Nagamit ko na ang kalahati ng mga pamamaraang ito, at na-encounter ko na ang kalahati."

"Great, ituloy na natin."

Mga Paraan ng Listahan<E>: interface:

Paraan	Paglalarawan
`void add(int index, E element);`	Nagdaragdag ng mga elemento sa gitna ng koleksyon
`boolean addAll(int index, Collection<? extends E> c);`	Nagdaragdag ng mga elemento sa koleksyon
`E get(int index);`	Nagbabalik ng elemento ayon sa index
`int indexOf(Object o);`	Ibinabalik ang index (numero) ng isang elemento
`int lastIndexOf(Object o);`	Ibinabalik ang index ng huling elemento.
`ListIterator<E> listIterator();`	Nagbabalik ng iterator para sa listahan
`ListIterator<E> listIterator(int index);`	Nagbabalik ng iterator para sa listahan
`E remove(int index);`	Tinatanggal ang isang elemento sa pamamagitan ng index nito
`E set(int index, E element);`	Nagtatakda ng bagong halaga ayon sa index
`List<E> subList(int fromIndex, int toIndex);`	Nagbabalik ng subcollection

"Nothing radically new here either. Alam ko na halos lahat ng collections, which I can't help but be happy about."

"Buweno, sa palagay ko ay makakahanap ako ng isang bagay na magugulat sa iyo. Ngunit ipagpatuloy natin ang pagsusuri sa mga interface:"

Mga Paraan ng Set<E>: interface:

Paraan	Paglalarawan
Walang mga pamamaraan

"Walang anumang bagong pamamaraan ang Set interface - ang mga minana lang nito."

"Oo, nakita ko na ang Interable na interface ay wala rin.

"Sa kabilang banda, ang mas kaunting mga pamamaraan ay nangangahulugang hindi gaanong matandaan!"

"Ang iyong positibong pananaw sa buhay ay nagpapasaya sa akin."

"Ang interface ng Set ay minana ng dalawang interface na may mga pamamaraan: SortedSet at NavigableSet. Ngunit hindi ko na babalikan ang mga ito, o hindi na natin matatapos."

"Sa halip, hayaan mo akong bigyan ka ng pangkalahatang larawan ng mga klase at interface na naglalarawan ng mga koleksyon sa Java."

"Dalhin mo."

"Kung gayon, kumapit ka ng mahigpit:"

"Wow, ang laki naman!"

"Well, hindi naman ganoon kalaki. Isa pa, tandaan na ang mga abstract na klase ay ganap na opsyonal. Ngunit magandang tandaan kung aling klase ang nagpapatupad ng kung aling mga interface. Iyon ay maaaring magamit nang madalas."

"Naku, gusto ko ring tandaan na ang ilang mga koleksyon ay itinuturing na hindi na ginagamit."

"Alin ang mga iyon?"

"Ang tinutukoy ko ay ang mga klaseng Vector, Stack, Dictionary, at Hashtable. Ito ay mga naka-synchronize (thread-safe) na bersyon ng mga ordinaryong koleksyon."

"Ngunit ang Java ay nagdagdag ng isang espesyal na concurrency library na may maraming mga koleksyon na hindi lamang maa-access mula sa iba pang mga thread, ngunit mayroon ding mas mahusay na pagpapatupad. Ang ConcurrentHashMap ay mas mahusay kaysa sa Hashtable ."

"Maaari mong gamitin ang mga koleksyon ng Vector, Stack, Dictionary, at Hashtable, ngunit hindi ito inirerekomenda."

"Got it, itatago ko 'yan sa isip ko."

"Salamat, Ellie!"