Mga iterator

"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:"

"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:"

"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 :"

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:"

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>:"

"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!"