Iterators

"Hallo Amigo!"

"Hallo, Ellie!"

"Vandaag wil ik je vertellen over iterators."

"Iterators zijn praktisch tegelijkertijd met collecties uitgevonden. Het belangrijkste doel van collecties is om elementen op te slaan, en het belangrijkste doel van een iterator is om deze elementen één voor één op te halen."

"Wat is er zo moeilijk aan het krijgen van een set elementen?"

"Ten eerste hebben de elementen in sommige collecties, zoals Set, geen vaste volgorde en/of verandert de volgorde voortdurend."

"Ten tweede kunnen sommige datastructuren objecten op een zeer complexe manier opslaan: in verschillende groepen, lijsten, enz. Met andere woorden, het zou een niet-triviale taak zijn om alle elementen op volgorde uit te delen."

"Ten derde hebben verzamelingen de neiging om te veranderen. Stel dat je besluit om de volledige inhoud van een verzameling weer te geven, maar precies in het midden van de uitvoer schakelt de JVM over naar een andere thread die de helft van de elementen van de verzameling vervangt. Dus in plaats van de uitvoer krijg je wie weet wat."

"Hm..."

"Maar! Dit zijn precies het soort problemen dat een iterator kan oplossen. Een iterator is een bijzonder object binnen een verzameling dat enerzijds toegang heeft tot al zijn privégegevens en de interne structuur kent, en anderzijds , implementeert de openbare Iterator-interface, waardoor iedereen weet hoe ermee te werken. "

"Sommige iterators hebben een interne array waarin alle elementen van de collectie worden gekopieerd wanneer de iterator wordt gemaakt. Dit zorgt ervoor dat latere wijzigingen in de collectie geen invloed hebben op het aantal of de volgorde van de elementen."

"Ik denk dat je dit bent tegengekomen bij het werken met voor elke . Je kunt niet tegelijkertijd een verzameling doorlopen en er elementen uit verwijderen. Dit komt allemaal precies door de manier waarop een iterator werkt."

"In de nieuwe collecties die aan de concurrency-bibliotheek zijn toegevoegd, is de iterator herwerkt om dit probleem op te lossen."

"Laat me je eraan herinneren hoe een iterator werkt."

"Java heeft een speciale Iterator-interface. Dit zijn de methoden:"

"Met een iterator kun je achtereenvolgens alle elementen van een verzameling ophalen. Het is logischer om een ​​iterator te zien als zoiets als een InputStream - het heeft alle gegevens, maar het is zijn taak om het sequentieel uit te voeren."

"De   methode next () retourneert het volgende element in de verzameling."

"De methode hasNext () wordt gebruikt om te controleren of er nog meer elementen zijn."

"En verwijder () verwijdert het huidige element."

"Nog vragen?"

"Waarom hebben de methoden zulke vreemde namen? Waarom isEmpty() en getNextElement() niet?"

"Zou dat niet logischer zijn?"

"Het zou logischer zijn, maar de namen kwamen uit de C++-taal, waar iterators eerder verschenen."

"Ik begrijp het. Laten we doorgaan."

"Naast een iterator is er ook de Iterable-interface, die moet worden geïmplementeerd door alle collecties die iterators ondersteunen. Het heeft één enkele methode:"

"Je kunt deze methode op elke verzameling gebruiken om een ​​iterator-object door zijn elementen te laten lopen. Laten we alle elementen van een TreeSet bekijken :"

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

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

"Het gebruik van een dergelijke iterator is niet erg handig - er is te veel overbodige en voor de hand liggende code. De situatie werd eenvoudiger toen de for-each- lus in Java verscheen."

"Nu is deze code veel compacter en leesbaarder:"

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);
}

"Dit is dezelfde code! In beide gevallen wordt de iterator gebruikt."

"Het gebruik ervan is alleen verborgen in de for-each- lus. Merk op dat de code aan de rechterkant helemaal geen rode tekst heeft. Het gebruik van de iterator is volledig verborgen."

"Een for-each- lus kan worden gebruikt voor alle objecten die iterators ondersteunen. Met andere woorden, u kunt uw eigen klasse schrijven, de methode iterator () eraan toevoegen en de objecten ervan in een for-each- constructie gebruiken."

"Wow! Natuurlijk sta ik niet te popelen om mijn eigen collecties en iterators te schrijven, maar het vooruitzicht is nog steeds verleidelijk. Ik zal het noteren."

Bovendien is er nog een ander populair type iterator dat zelfs zijn eigen interface heeft. Ik heb het over een iterator voor lijsten, dat wil zeggen ListIterator .

"Ongeacht hun implementatie behouden lijsten de volgorde van elementen, wat het werken met ze via een iterator een beetje handiger maakt."

"Dit zijn de methoden van de ListIterator <E>-interface:"

"Met andere woorden, hier kunnen we zowel vooruit als achteruit gaan. En er zijn nog een paar andere kleine kenmerken."

"Nou, dat is interessant spul. Waar wordt het gebruikt?"

"Stel dat u heen en weer wilt gaan op een gelinkte lijst. De get-bewerking zal nogal traag zijn, maar de next()-bewerking zal erg snel zijn."

"Hmm. Je hebt me overtuigd. Ik zal het in gedachten houden."

"Bedankt, Ellie!"