Mga iterator

Mga Koleksyon ng Java
Antas , Aral
Available

"Hi, Amigo!"

"Hi, Ellie!"

"Ngayon gusto kong sabihin sa iyo ang tungkol sa mga iterator."

"Ang mga iterator ay naimbento nang halos kasabay ng mga koleksyon. Ang pangunahing layunin ng mga koleksyon ay mag-imbak ng mga elemento, at ang pangunahing layunin ng isang iterator ay upang kunin ang mga elementong ito nang paisa-isa."

"Ano ang mahirap sa pagkuha ng isang hanay ng mga elemento?"

"Una, ang mga elemento sa ilang mga koleksyon, gaya ng Set, ay walang itinatag na pagkakasunud-sunod at/o patuloy na nagbabago ang order."

"Pangalawa, ang ilang mga istruktura ng data ay maaaring mag-imbak ng mga bagay sa isang napakakomplikadong paraan: sa iba't ibang mga grupo, mga listahan, atbp. Sa madaling salita, ang pagbibigay ng lahat ng mga elemento sa pagkakasunud-sunod ay magiging isang hindi maliit na gawain."

"Ikatlo, ang mga koleksyon ay may posibilidad na magbago. Ipagpalagay na nagpasya kang ipakita ang buong nilalaman ng isang koleksyon, ngunit sa gitna mismo ng output ay lumipat ang JVM sa isa pang thread na pumapalit sa kalahati ng mga elemento ng koleksyon. Kaya sa halip na ang output, makakakuha ka sino ang nakakaalam kung ano."

"Hmm..."

"Ngunit! Ito ang eksaktong uri ng mga problema na malulutas ng isang iterator. Ang iterator ay isang espesyal na bagay sa loob ng isang koleksyon na, sa isang banda, ay may access sa lahat ng pribadong data nito at alam ang panloob na istraktura nito, at sa kabilang banda, , ay nagpapatupad ng pampublikong interface ng Iterator, na nagpapaalam sa lahat kung paano ito gagawin. "

"Ang ilang mga iterator ay may panloob na hanay kung saan ang lahat ng mga elemento ng koleksyon ay kinopya kapag ang iterator ay ginawa. Ito ay nagsisiguro na ang anumang kasunod na mga pagbabago sa koleksyon ay hindi makakaapekto sa bilang o pagkakasunud-sunod ng mga elemento."

"Sa palagay ko ay nakita mo na ito kapag nagtatrabaho para sa bawat . Hindi mo maaaring sabay-sabay na mag-loop sa isang koleksyon at mag-alis ng mga elemento mula dito. Ito ay lahat nang eksakto dahil sa paraan ng paggana ng isang iterator."

"Sa mga bagong koleksyon na idinagdag sa concurrency library, ang iterator ay muling ginawa upang maalis ang problemang ito."

"Hayaan mong ipaalala ko sa iyo kung paano gumagana ang isang iterator."

"May espesyal na interface ng Iterator ang Java. Narito ang mga pamamaraan nito:"

Mga Paraan ng Interface ng Iterator<E> Paglalarawan
boolean hasNext() Sinusuri kung mayroon pang mga elemento
E next() Ibinabalik ang kasalukuyang elemento at lilipat sa susunod.
void remove() Tinatanggal ang kasalukuyang elemento

"Ang isang iterator ay nagbibigay-daan sa iyong sunud-sunod na makuha ang lahat ng mga elemento ng isang koleksyon. Mas lohikal na isipin ang isang iterator bilang isang bagay tulad ng isang InputStream — mayroon itong lahat ng data, ngunit ang gawain nito ay i-output ito nang sunud-sunod."

"Ang   susunod na () na pamamaraan ay nagbabalik ng susunod na elemento sa koleksyon."

"Ang hasNext () na paraan ay ginagamit upang suriin kung mayroon pang mga elemento."

"At alisin () ang kasalukuyang elemento."

"May tanong?"

"Bakit may mga kakaibang pangalan ang mga pamamaraan? Bakit hindi isEmpty() at getNextElement()?"

"Hindi ba mas makatuwiran iyon?"

"Ito ay mas makatuwiran, ngunit ang mga pangalan ay nagmula sa C++ na wika, kung saan ang mga iterator ay lumitaw nang mas maaga."

"I see. Let's continue."

"Bilang karagdagan sa isang iterator, mayroon ding Iterable na interface, na dapat ipatupad ng lahat ng mga koleksyon na sumusuporta sa mga iterator. Mayroon itong isang paraan:"

Mga pamamaraan ng Interable<T> na interface Paglalarawan
Iterator<T>iterator() Nagbabalik ng iterator object

"Maaari mong gamitin ang paraang ito sa anumang koleksyon upang makakuha ng isang iterator na bagay na dumaan sa mga elemento nito. Maglakad tayo sa lahat ng mga elemento ng sa isang TreeSet :"

Halimbawa
TreeSet<String> set = new TreeSet<String>();
Iterator<String> iterator = set.iterator();

while (iterator.hasNext())
{
 String item = iterator.next();
 System.out.println(item);
}

"Ang paggamit ng isang iterator na tulad nito ay hindi masyadong maginhawa — mayroong masyadong maraming kalabisan at halatang code. Naging mas simple ang sitwasyon nang lumitaw ang para sa bawat loop sa Java."

"Ngayon ang code na ito ay mas compact at nababasa:"

dati Pagkatapos
TreeSet<String> set = new TreeSet<String>();
Iterator<String> iterator = set.iterator();

while (iterator.hasNext())
{
 String item = iterator.next();
 System.out.println(item);
}
TreeSet<String> set = new TreeSet<String>();

for(String item : set)
{
 System.out.println(item);
}

"Ito ay ang parehong code! Ang iterator ay ginagamit sa parehong mga kaso."

"It's just that ang paggamit nito ay nakatago sa for-each loop. Tandaan na ang code sa kanan ay walang pulang text. Ang paggamit ng iterator ay ganap na nakatago."

"Ang isang para sa bawat loop ay gagamitin para sa anumang mga bagay na sumusuporta sa mga iterator. Sa madaling salita, maaari mong isulat ang iyong sariling klase, idagdag ang iterator () na paraan dito, at gamitin ang mga bagay nito sa isang para sa bawat konstruksyon."

"Wow! Syempre, hindi ako sabik na magsulat ng sarili kong mga collection at iterator, pero nakakatukso pa rin ang prospect. I'll make a note of it."

Bukod pa rito, may isa pang sikat na uri ng iterator na kahit na may sarili nitong interface. Pinag-uusapan ko ang tungkol sa isang iterator para sa mga listahan, ie ListIterator .

"Anuman ang kanilang pagpapatupad, pinapanatili ng mga listahan ang pagkakasunud-sunod ng mga elemento, na ginagawang mas maginhawa ang pagtatrabaho sa kanila sa pamamagitan ng isang iterator."

"Narito ang mga pamamaraan ng interface ng ListIterator <E>:"

Pamamaraan Paglalarawan
boolean hasNext() Sinusuri kung mayroon pang mga elemento sa unahan.
E next() Ibinabalik ang susunod na elemento.
int nextIndex() Ibinabalik ang index ng susunod na elemento
void set(E e) Binabago ang halaga ng kasalukuyang elemento
boolean hasPrevious() Sinusuri kung mayroong anumang mga elemento sa likod.
E previous() Ibinabalik ang nakaraang elemento
int previousIndex() Ibinabalik ang index ng nakaraang elemento
void remove() Tinatanggal ang kasalukuyang elemento
void add(E e) Nagdaragdag ng elemento sa dulo ng listahan.

"Sa madaling salita, dito maaari tayong sumulong at paatras. At mayroong ilang iba pang maliliit na tampok."

"Well, that's interesting stuff. Saan ito ginagamit?"

"Ipagpalagay na gusto mong lumipat pabalik-balik sa isang naka-link na listahan. Ang get operation ay medyo mabagal, ngunit ang susunod na() operation ay magiging napakabilis."

"Hmm. You convinced me. I'll keep it in mind."

"Salamat, Ellie!"

Mga komento
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION