java iterator learn use iterators java with examples
En aquest tutorial, aprendrem sobre els iteradors de Java. Tindrem un debat detallat sobre les interfícies Iterator i ListIterator a Java:
Hem explorat tot sobre Java Collection Framework i les seves diverses interfícies i classes de suport en un dels nostres tutorials anteriors.
Quan tingueu una col·lecció, voleu accedir als seus elements, afegir / eliminar o processar els elements. Per fer tot aquest processament mitjançant un programa Java, hauríeu de poder recórrer la col·lecció que esteu utilitzant. Aquí és on apareix l’iterador.
Què aprendreu:
- Què és un iterador de Java?
- Conclusió
Què és un iterador de Java?
A Java, un iterador és una construcció que s’utilitza per recórrer o recórrer la col·lecció.
Per utilitzar un iterador, heu d’obtenir l’objecte iterador mitjançant la tecla “ iterador () ” mètode de la interfície de col·lecció. Java Iterator és una interfície de framework de col·lecció i forma part del paquet 'java.util'. Mitjançant Java Iterator podeu recórrer la col·lecció d'objectes.
La interfície Java Iterator substitueix l'enumerador que es feia servir anteriorment per recórrer algunes col·leccions senzilles com els vectors.
Les principals diferències entre Java Iterator i Enumerator són:
- Millora considerable en els noms dels mètodes.
- Podeu eliminar elements del mètode de la col·lecció que s'està recorrent mitjançant un iterador.
En aquest tutorial, analitzarem els detalls de la interfície Iterator i la interfície ListIterator que és una interfície bidireccional.
Tipus d'iteradors
- Enumerador
- Iterador
- ListIterator
Ara, rarament s’utilitza un Enumerador. Per tant, a la nostra sèrie de tutorials, ens centrarem en les interfícies Iterator i ListIterator.
Interfície iteradora en Java
La interfície Iterator de Java forma part del marc de col·leccions del paquet ‘java.util’ i és un cursor que es pot utilitzar per recórrer la col·lecció d’objectes.
La interfície Iterator té les següents característiques principals:
- La interfície Iterator està disponible des del marc de col·lecció Java 1.2 en endavant.
- Recorre la col·lecció d’objectes d’un en un.
- Conegut popularment com a 'cursor universal de Java', ja que funciona amb totes les col·leccions.
- Aquesta interfície admet operacions de 'lectura' i 'eliminació', és a dir, podeu eliminar un element durant una iteració mitjançant l'iterador.
A continuació es proporciona la representació general de la interfície iteradora:
A continuació, fem una ullada als mètodes Iterator que s’enumeren més amunt.
Mètodes iteradors
La interfície Iterator admet els mètodes següents:
# 1) Següent ()
Prototip: E next ()
Paràmetres: sense paràmetres
Tipus de devolució: E -> element
Descripció: Retorna el següent element de la col·lecció.
Si la iteració (col·lecció) no té més elements, es llença NoSuchElementException .
# 2) hasNext ()
Prototip: booleà hasNext ()
Paràmetres: NUL
Tipus de devolució: true => hi ha elements a la col·lecció.
Fals => no més elements
Descripció: La funció hasNext () comprova si hi ha més elements a la col·lecció als quals s’accedeix mitjançant un iterador. Si no hi ha més elements, no crideu al mètode next (). En altres paraules, aquesta funció es pot utilitzar per decidir si es vol cridar al mètode next ().
# 3) elimina ()
Prototip: void remove ()
Paràmetres: NUL
Tipus de devolució: NUL
Descripció: Elimina l'últim element retornat per l'iterador que itera sobre la col·lecció subjacent. El mètode remove () només es pot cridar una vegada per cada següent trucada ().
Si l’iterador no admet l’operació d’eliminació, llança UnSupportedOperationException . Llança IllegalStateException si encara no s’anomena el següent mètode.
# 4) forEachRemaining ()
Prototip: void forEachRemaining (consumidorÉS > acció)
Paràmetres: acció => acció a realitzar
Tipus de devolució: buit
Descripció: Realitza l'acció especificada en cadascun dels elements restants de la col·lecció fins que s'esgotin tots els elements o l'acció generi una excepció. Les excepcions generades per acció es propaguen a la persona que truca.
Si l'acció és nul·la, llavors augmenta nullPointerException . Aquesta funció és una nova addició a la interfície Iterator de Java 8.
Exemple d'iterador de Java
Implantem un programa Java per demostrar l’ús de la interfície Iterator. El programa següent crea una ArrayList de flors. A continuació, obté un iterador mitjançant el mètode iterator () de l'ArrayList. Després d'això, es recorre la llista per mostrar cada element.
import java.util.*; public class Main { public static void main(String() args) { List flowers = new ArrayList(); flowers.add('Rose'); flowers.add('Jasmine'); flowers.add('sunflower'); // Get Iterator IteratorflowersIterator = flowers.iterator(); System.out.println('Contents of ArrayList:'); // Traverse elements using iterator while(flowersIterator.hasNext()){ System.out.print(flowersIterator.next() + ' '); } } } Sortida:
Limitacions de la interfície iteradora
- L'operació per substituir un element o afegir un element nou no es pot realitzar amb aquest iterador.
- La iteració només procedeix en una direcció, és a dir, la direcció cap endavant.
- Només admet la iteració seqüencial.
- Quan es volen iterar grans volums de dades, el rendiment de l'iterador es veu afectat.
Iterador VsIterable
Tot i que les interfícies Iterable i Iterator sonen semblants, són completament diferents. Una classe que implementa la interfície Iterable adquireix la possibilitat d'iterar sobre els objectes de classe que utilitzen la interfície iteradora.
A continuació es detallen algunes de les principals diferències entre aquestes dues interfícies que heu de tenir en compte:
| Interfície iterable | Interfície iteradora |
|---|---|
| Representa una col·lecció que es pot recórrer mitjançant el bucle foreach. | Permet repetir alguna altra col·lecció. |
| La classe que implementa la interfície iterable ha de substituir el mètode iterator (). | Els mètodes hasNext () i next () de la interfície Iterator han de ser anul·lats per la classe que ho implementi. |
| No emmagatzema l'estat actual. | Emmagatzema l'estat actual de la iteració. |
| S'ha de produir una instància de la interfície d'iterador cada vegada que es crida el mètode iterator (). | No hi ha cap contracte per a la interfície iteradora. |
| Es mou només en direcció cap endavant. | Es mou cap endavant i les subinterfícies com el listIterator admet el recorregut bidireccional. |
| No proporciona cap mètode per modificar els elements durant la iteració. | Proporciona el mètode d'eliminació que pot eliminar l'element quan la iteració està en curs. |
Interfície ListIterator a Java
La interfície ListIterator és una subinterfície de la interfície iteradora. Funciona en col·leccions de tipus de llista, com ara Llistes enllaçades, llistes de matrius, etc. Per tant, aquesta interfície supera les deficiències de la interfície Iterator.
Les principals característiques de la interfície ListIterator són:
- La interfície ListIterator amplia la interfície Iterator.
- La interfície ListIterator admet operacions CRUD, és a dir, Crear, llegir, actualitzar i suprimir.
- Admet la iteració tant cap endavant com cap enrere.
- Com que aquesta interfície és bidireccional, el cursor sempre es situa entre els elements anterior i següent.
- Aquesta interfície funciona principalment per a implementacions de llistes com ArrayList, LinkedList, etc.
- Disponible des de Java 1.2
La interfície ListIterator es representa com es mostra a continuació:
Com ja s'ha esmentat, la interfície ListIterator amplia la interfície Iterator. Així, a part de donar suport a tots els mètodes de la interfície iteradora, tal com es representa a la interfície ListIterator, també hi ha mètodes propis que l'ajuden a realitzar operacions CRUD, així com la iteració bidireccional.
Analitzem detalladament els mètodes ListIterator.
Mètodes ListIterator
Tingueu en compte que els mètodes de la interfície Iterator, next (), hasNext () i remove () funcionen exactament, de la mateixa manera, que la interfície ListIterator. Per tant, ometrem aquests mètodes en aquesta secció. A més dels mètodes esmentats anteriorment, ListIterator té els mètodes següents:
Anterior ()
Prototip: E anterior ()
Paràmetres: NUL
Tipus de devolució:
E- element anterior de la llista.
- 1 - si l'iterador es troba al principi de la llista.
Descripció: Aquesta funció retorna l'element anterior de la llista. Un cop es retorna l'element anterior, el cursor es mou cap enrere cap a l'element següent.
hasPrevious ()
Prototip: booleà hasPrevious ()
Paràmetres: NUL
Tipus de devolució: true => iterador té més elements quan es recorre la llista cap enrere.
Descripció: Aquesta funció comprova si el ListIterator té més elements en sentit invers.
índex anterior
Prototip: int previousIndex ()
Paràmetres: NUL
Tipus de devolució:
int - índex de l'element anterior
- 1 - si el punter es troba al començament de la llista.
Descripció: Retorna l'índex de l'element anterior que retorna la trucada anterior ().
nextIndex
Prototip: int nextIndex ()
Paràmetres: NUL
Tipus de devolució:
int - índex següent
- 1 - si l'iterador es troba al final de la llista.
Descripció: Retorna el següent índex de l'element de la llista. Aquest element es retorna mitjançant una trucada al mètode next ().
conjunt()
Prototip: conjunt buit (E i)
Paràmetres: e - element a substituir
Tipus de devolució: NUL
Descripció: S'utilitza per substituir l'últim element per l'element donat e.
add ()
Prototip: void add (E e)
Paràmetres: e - element que cal afegir
Tipus de devolució: NUL
Descripció: Afegeix elements nous a la llista en una posició anterior a la de l'element next ().
Exemple de llista d'iteradors
Ara sabem què és un ListIterator i quins són els diversos mètodes que admet. Anem endavant i implementem un programa Java per demostrar el ListIterator.
En aquest programa, hem utilitzat ArrayList. A continuació, utilitzem els mètodes ListIterator per recórrer la llista en la direcció cap endavant i cap enrere i mostrar la sortida.
import java.util.*; class Main { public static void main(String args()) { Listnum_list = new ArrayList(); // Add Elements to ArrayList num_list.add(1); num_list.add(3); num_list.add(5); num_list.add(7); num_list.add(9); // Creatinge a ListIterator ListIteratorlist_it = num_list.listIterator(); System.out.println('Output using forward iteration:'); while (list_it.hasNext()) System.out.print(list_it.next()+' ') ; System.out.print('
Output using backward iteration:
') ; while (list_it.hasPrevious()) System.out.print(list_it.previous()+' '); } } Sortida:
Fins ara hem debatut sobre les interfícies, l'iterador i el listiterador, a continuació veurem els diversos exemples d'ús d'aquestes interfícies per recórrer diferents col·leccions. Però, primer, examinem el recorregut de matrius senzills i després passem a altres col·leccions.
Array Iterator
A Java, hi ha dues maneres d'iterar sobre els elements de matriu. Descrivim les formes d’utilitzar exemples de codi.
# 1) per a bucle
Aquesta és la forma més senzilla d'iterar sobre una matriu. Utilitzem un bucle simple que incrementarà l’índex amb cada iteració i mostrarà el seu contingut.
import java.util.*; public class Main { public static void main(String() args) { int myArray() = {2,4,6,8,10,12,14}; int num; System.out.println('Array contents using for loop:'); for (int i = 0; i Sortida:
El programa anterior mostra el contingut de la matriu mitjançant el bucle for.
# 2) per a cada bucle
Aquesta és la segona forma d’iterar sobre matrius. Aquí fem servir un bucle especialitzat per a bucle o 'per a cada'. Aquí fem un recorregut per la matriu de cada element i després mostrem el contingut.
import java.util.*; public class Main { public static void main(String() args) { int myArray() = {2,4,6,8,10,12,14}; int num; System.out.println('Array contents using for each loop:'); for (int i :myArray) { // accessing each element of array num = i; System.out.print(num + ' '); } } } Sortida:
El forEach està més optimitzat en comparació amb el bucle for. És més curt d’escriure i també és més ràpid.
ArrayList Iterator
En cas que vulgueu recórrer una col·lecció ArrayList, podeu fer-ho mitjançant la interfície Iterator. Com que l'iterador és una interfície, no es pot instanciar directament. En lloc d’això, podeu utilitzar el mètode iterator () de la col·lecció ArrayList per obtenir l’iterador i, a continuació, recórrer la llista.
Iterador iterador ();
Exemple per demostrar l'iterador ArrayList.
import java.util.*; public class Main { public static void main(String() args) { ArrayListmyList = new ArrayList(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); myList.add('Brown'); myList.add('Pink'); myList.add('Purple'); Iteratorlist_it = myList.iterator(); System.out.println('Elements in the arrayList:'); while(list_it.hasNext()) System.out.print(list_it.next() + ' '); } } Sortida:
LinkedList Iterator
Ara vegem la funcionalitat d'un iterador en cas de col·lecció LinkedList.
La col·lecció LinkedList admet el mètode listIterator () que retorna el listIterator per recórrer la llista enllaçada.
El format general d'aquesta funció és
ListIterator list_iter = LinkedList.listIterator (int index);
Aquí, l'índex és un valor enter que especifica la posició a la col·lecció de llista enllaçada des d'on hauria de començar el recorregut.
Compreneu l'iterador de la llista de la llista enllaçada amb un programa de mostra. Hem modificat el mateix programa iterador de matriu i l’hem canviat per contenir un lliterador amb la llista enllaçada.
import java.util.*; public class Main { public static void main(String() args) { LinkedListmyList = new LinkedList(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); myList.add('Brown'); myList.add('Pink'); myList.add('Purple'); ListIteratorlist_it = myList.listIterator(0); System.out.println('Elements in the LinkedList:'); while(list_it.hasNext()) System.out.print(list_it.next() + ' '); } } Sortida:
com obrir fitxers bin al Windows
Java Map / Hashmap Iterator
El mapa o les seves variacions com a hashmap, treemap, etc. no són col·leccions. Per tant, no podeu utilitzar directament el mètode iterador. En lloc d’això, hauríeu d’iterar els valors d’entrada de clau per llegir els parells clau / valor.
Tot i que podeu fer servir diversos mètodes com forEach, for loop, etc. per repetir els valors del mapa, fer servir un iterador per recórrer els valors clau és el mètode millor i eficient. A més, també podeu eliminar les entrades del mapa durant la iteració mitjançant el mètode remove.
Exemple d'ús de l'iterador amb HashMap.
import java.util.*; class Main { public static void main(String() arg) { MapmyMap = new HashMap(); // enter name/url pair myMap.put(1, 'India'); myMap.put(2, 'Nepal'); myMap.put(3, 'Maldives'); myMap.put(4, 'SriLanka'); System.out.println(' SAARC Member Countries '); System.out.println(' KEY' + ' ' + ' COUNTRY' ); // using iterators Iteratormap_itr = myMap.entrySet().iterator(); while(map_itr.hasNext()) { Map.Entrymap_entry = map_itr.next(); System.out.println(' ' + map_entry.getKey() + ' ' + map_entry.getValue()); } } } Sortida:
Al programa anterior, hem definit un mapa amb claus senceres i valors de tipus de cadena. A continuació, definim un iterador sobre el mapa. Introduïu i mostreu els parells clau / valor.
Java Set Iterator
El mètode iterator () de Java.util.set s’utilitza per obtenir l’iterador que retorna els elements del conjunt en ordre aleatori.
Iterator set_iterator = Set.iterator();El 'set_iterator' repassa els diferents elements del conjunt i retorna els seus valors.
De manera similar, el conjunt de hash també conté una funció d'iterador que retorna un iterador com un iterador de conjunts.
Iterator hashset_iterator = Hash_Set.iterator(); A continuació es mostra l'exemple de programació per demostrar l'iterador de conjunts.
import java.util.*; public class Main { public static void main(String args()) { HashSetsports_set = new HashSet(); sports_set.add('Hocky'); sports_set.add('Kabaddi'); sports_set.add('Football'); sports_set.add('Badminton'); sports_set.add('Cricket'); System.out.println('Sports HashSet: ' + sports_set); // Creating an iterator Iterator hashset_iter = sports_set.iterator(); // Displaying the values after iterating through the set System.out.println('
SportsSet iterator values:'); while (hashset_iter.hasNext()) { System.out.println(hashset_iter.next()); } } } Sortida:
Aquesta implementació utilitza el fitxer Iterador de HashSet i mostra valors individuals iterant sobre els elements HashSet.
Iterator vs ListIterator
Tabulem les principals diferències entre les interfícies Iterator i ListIterator.
Iterador ListIterator Pot recórrer totes les col·leccions, inclosos el conjunt, el mapa, etc. Es pot utilitzar per recórrer només col·leccions de tipus de llista com ArrayList, LinkedList. Itera la col·lecció només en sentit avançat. Es pot recórrer la col·lecció tant en direcció avançada com inversa. No es poden obtenir índexs. Pot obtenir índexs. No hi ha manera d’afegir elements nous a la col·lecció. Podeu afegir elements nous a la col·lecció. Iterator no pot modificar els elements durant la iteració. ListIterator pot modificar els elements de la col·lecció mitjançant el mètode set ().
Preguntes freqüents
P # 1) Què és la iteració a Java?
Resposta: Una iteració és un procés mitjançant el qual s’executa repetidament un bloc de codi fins que es manté o no existeix una condició determinada. Mitjançant la iteració podeu recórrer una seqüència d’elements o processar les dades.
Q # 2) Quants tipus d'iteradors hi ha a Java?
Resposta: Els iteradors s’utilitzen per recórrer les col·leccions de Java.
Hi ha tres tipus d’iteradors a Java:
- Enumeradors
- Iteradors
- ListIterators
P # 3) Com puc utilitzar un iterador a Java?
Resposta: Per utilitzar l’iterador per recórrer la col·lecció, primer cal que l’iterador utilitzi el mètode iterator () de la col·lecció especificada.
A continuació, podeu utilitzar els mètodes hasNext () i next () de l'iterador per obtenir l'element.
Q # 4) Per què s'utilitza Iterator en lloc de bucle?
Resposta: Tant l'iterador com el bucle s'utilitzen per executar repetidament un bloc de codi específic. Però la diferència principal és que en el bucle for no podeu alterar ni modificar el contingut de la col·lecció. Fins i tot si intenteu modificar-lo, llançarà concurrentModificationException. Mitjançant l'iterador podeu eliminar un element de la col·lecció.
Q # 5) Per què necessitem Iterator a Java?
Resposta: Iterator us ajuda a recuperar els elements de la col·lecció o d’un contenidor sense que el programador hagi de conèixer l’estructura interna ni el funcionament de la col·lecció. Són més elegants, consumeixen menys memòria i, a més, el programador no li escriu un codi llarg.
En segon lloc, els elements es poden emmagatzemar a la col·lecció de qualsevol manera, però mitjançant un iterador, el programador els pot recuperar igual que una llista o qualsevol altra seqüència.
Conclusió
Hem comentat els iteradors de Java que s’utilitzen amb les col·leccions d’aquest tutorial. Aquest coneixement dels iteradors ajudarà els lectors a comprendre les col·leccions que aprendrem en els nostres tutorials posteriors.
Lectura recomanada
- Interfície Java i tutoria de classes abstractes amb exemples
- Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java
- Desplegament de Java: creació i execució del fitxer JAR de Java
- Paraula clau 'aquesta' de Java: tutorial amb exemples de codi
- Màquina virtual Java: com ajuda JVM a executar aplicacions Java
- Modificadors d'accés a Java: tutorial amb exemples
- Tutorial de reflexió de Java amb exemples
- C ++ contra Java: les 30 diferències principals entre C ++ i Java amb exemples
