En Iterator i Java är en av de mest använda markörer i Java Collections Framework . Den används för att gå igenom eller iterera genom element i en samling en efter en.

skillnaden mellan $ och $$

• Den används endast för att korsa element i framåtriktningen.
• Tar bort element säkert under traversering med remove().
• Iterator är en universell markör som gäller för alla samlingstyper — Listuppsättning och Kö.

Deklaration av Iterator

offentligt gränssnitt Iterator

Här representerar E typen av element som ska itereras över.

Objektskapande av Iterator

Ett Iterator-objekt skapas genom att anropa iterator()-metoden på ett samlingsobjekt. Här kommer vi att använda en Iterator för att gå igenom och skriva ut varje element i en ArrayList .

Samlingnamn = ny ArrayList<>();
Iteratoritr = names.iterator();

import java.util.ArrayList; import java.util.Iterator; public class Geeks {  public static void main(String[] args) {    // Create an ArrayList and add some elements  ArrayList<String> al = new ArrayList<>();  al.add('A');  al.add('B');  al.add('C');  // Obtain an iterator for the ArrayList  Iterator<String> it = al.iterator();  // Iterate through the elements and print each one  while (it.hasNext()) {    // Get the next element  String n = it.next();   System.out.println(n);   }  } } 

A B C 

Iteratorns hierarki

Iterator är en del av java.util-paketet och implementeras av alla samlingsklasser genom deras undergränssnitt.

Metoder för iteratorgränssnitt

Iteratorgränssnittet definierar tre metoder som listas nedan:

• hasNext(): Returnerar sant om iterationen har fler element.
• nästa(): Returnerar nästa element i iterationen. Det kastar NoSuchElementException om inget mer element är närvarande.
• ta bort(): Tar bort det sista elementet som returneras av next(). Denna metod kan endast anropas en gång per anrop till next().

Notera : remove()-metoden kan ge två undantag, nämligen enligt följande:

Internt arbete

I det här avsnittet ska vi försöka förstå hur Java Iterator och dess metoder fungerar internt. Låt oss ta följande LinkedList-objekt för att förstå denna funktionalitet.

Steg 1: Låt oss nu skapa ett Iterator-objekt på List-objektet som visas nedan:

IteratorstäderIterator = städer.iterator();

Iteratorn 'citiesIteartor' kommer att se ut så här:

sträng till itn

Här pekar Iterators markör före det första elementet i listan.

Steg 2: Nu kör vi följande kodavsnitt.

städerIterator.hasNext();
städerIterator.next();

När vi kör ovanstående kodavsnitt pekar Iterators markör på det första elementet i listan som visas i diagrammet ovan.

Steg 3: Nu kör vi följande kodavsnitt.

städerIterator.hasNext();
städerIterator.next();

När vi kör ovanstående kodavsnitt pekar Iterators markör på det andra elementet i listan som visas i diagrammet ovan.

Steg 4: Gör denna process för att nå Iteratorns markör till slutet av listan.

Steg 5: Efter att ha läst det sista elementet om vi kör kodavsnittet nedan returnerar det ett falskt värde.

städerIterator.hasNext();

Som Iterators markör pekar på efter det sista elementet i listan hasNext() metod returnerar ett falskt värde.

Notera: Java Iterator stöder endast iteration i framåtriktad riktning så den är känd som en enkelriktad markör. Däremot är ListIterator dubbelriktad och tillåter genomflyttning i båda riktningarna.

python bytes till sträng

Exempel: Här kommer vi att använda en Iterator för att korsa och ta bort udda element från en ArrayList.

import java.util.ArrayList; import java.util.Iterator; public class Geeks {  public static void main(String[] args) {    // Creating an ArrayList of Integer type  ArrayList<Integer> al = new ArrayList<>();  // Adding elements to the ArrayList  for (int i = 0; i < 10; i++) {  al.add(i);  }  // Printing the original list  System.out.println('Original List: ' + al);  // Creating an Iterator for the ArrayList  Iterator<Integer> itr = al.iterator();  // Iterating through the list and removing odd elements  while (itr.hasNext()) {    // Getting the next element  int i = itr.next();     System.out.print(i + ' ');   // Removing odd elements  if (i % 2 != 0) {  itr.remove();  }  }  System.out.println();  // Printing the modified list after removal of odd elements  System.out.println('Modified List: ' + al);  } } 

Original List: [0 1 2 3 4 5 6 7 8 9] 0 1 2 3 4 5 6 7 8 9 Modified List: [0 2 4 6 8] 

Förklaring: I exemplet ovan skapar vi en ArrayList med heltal och itererar sedan genom den med en Iterator och tar bort alla udda tal. Den skriver ut listan före och efter att de udda elementen tagits bort och den ändrade listan skrivs ut med endast jämna nummer.