Java >> Java tutorial >  >> Java

Iteratorer i Java

Java

Hvis du er nybegynder til Java eller endda en erfaren programmør, kan du stå over for en situation, hvor du har brug for at krydse gennem alle elementerne i en samling, vise elementerne et efter et eller endda hente hvert af elementerne. Det er her din viden om iteratorer vil være ved testen.

Hvad er forskellen mellem at bruge iteratorer i stedet for at bruge for-løkken og while-løkken? Begge disse kan bruges til at krydse gennem en samling af elementer, men hvis du har brug for at fjerne nogle af elementerne fra en samling under iteration, så kan loops ikke anvendes.

Med iteration mener vi at krydse elementerne en efter en. Dette involverer elementer af en samling såsom LinkedList, ArrayList, HashMap e.t.c. Iteratorer er anvendelige, når man ønsker at søge efter et bestemt element i en samling, vise elementerne ét efter ét, få adgang til dataelementer i en samling og fjerne specifikke dataelementer fra samlingen.

Det er ikke muligt at vende gentagelsesrækkefølgen. Iteratorer itererer over en samling i videresendelsesrækkefølge, og de implementerer java. util.Iterator-grænseflade. Når det er sagt, kan vi konkludere, at en iterator hører til Java Collection-rammeværket.

Erklæring af en iterator

Iterator iterator_name = name_of_collection.iterator();
eg.
Iterator<Integer> numbers = values.iterator();

Metoder brugt af iteratorer

  • Ugyldig fjernelse () – =denne metode bruges til at fjerne det aktuelle element, som iteratoren peger på. Hvis du kalder metoden remove() uden at påberåbe næste() metoden, udløses en IllegalStateException.
  • Objekt næste () =denne metode returnerer det næste element. Hvis der ikke er noget næste element, kastes NoSuchElementException.
  • Boolean hasNext() ==denne metode returnerer sand i et scenarie, hvor vi har næste element, ellers  returnerer falsk.

Eksempel: 

package iterator;
import java.util.ArrayList;
import java.util.Iterator;
public class Iterator {
    public static void main(String[] args) {
          ArrayList<Integer> values = new ArrayList<Integer>();
        values.add(10);
        values.add(20);
        values.add(30);
        values.add(40);
        values.add(50);
        values.add(60);
        values.add(70);
        values.add(80);
        values.add(90);
       Iterator<Integer> numbers = values.iterator();
        while (numbers.hasNext()) 
        {
            int number = numbers.next();
            System.out.print(number + " ");
            if (number == 30)
                numbers.remove();
        }
        System.out.println("\n================");
        numbers = values.iterator();
        while (numbers.hasNext()) 
        {
            int number = numbers.next();
            System.out.print(number + " ");
        }        
    }
    
}

Output:

run:
10 20 30 40 50 60 70 80 90 
================
10 20 40 50 60 70 80 90 BUILD SUCCESSFUL (total time: 0 seconds)

Fra ovenstående eksempel har vi anvendt alle de tre metoder i en iterator:next( ), remove( ) og hasNext( ). Vi har brugt to while-løkker. Den første while-løkke udskriver alle elementerne op til et punkt, hvor iteratoren ikke har noget næste element. Det fjerner også '30' fra ArrayList. Den anden while-løkke udskriver værdierne af ArrayList efter fjernelse af element 30.

Vigtige funktioner i Iteratorer i Java

  • Gør det muligt at krydse elementer i en samling
  • Tillad adgang til elementer i en samling
  • Aktiverer visning af elementer ét efter ét i en samling
  • Tillader fjernelse af et element i en samling, mens du får adgang til det
  • Tillader fremadgående retningsadgang for elementer i en samling

Eksempler på iteratorer i java

Liste Iterator

Dette er en iterator, der går på tværs af en liste. Det gælder kun for klasser som Array List og LinkedList. En listeiterator muliggør tovejs transversering. Den bruger sine metoder 'hasNext ( )' og 'next ( )' til iteration.

package iterator;
import java.util.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class Iterator {
    public static void main(String[] args) {
         // create a list
	List<String> cars = new ArrayList<String>();
	// add elements
	cars.add("Toyota");
	cars.add("Benz");
	cars.add("Mercidez");
        cars.add("Noah");
        cars.add("Corolla");
	// get iterator over the list
	java.util.Iterator<String> iterator = cars.iterator();
	// iterate over the list
	while (iterator.hasNext()) {
		// get current element
		String element = iterator.next();
		System.out.println(element);
	}        
    }    
}

Output:

run:
Toyota
Benz
Mercidez
Noah
Corolla
BUILD SUCCESSFUL (total time: 0 seconds)

Fra ovenstående eksempel startede vi med at lave en liste over biler. Tilføjede elementer til listen ved hjælp af 'add( )'-metoden. For at gentage listen har vi oprettet en iterator. Brugte hasNext ( ) og next ( ) metoderne til at gentage og vise listeelementerne.

Indstil Iterator

Vi kan også udføre en iteration over et sæt. I java omtaler vi et sæt som en samling, der ikke indeholder duplikerede elementer. Java har tre generelle sæt implementeringer, som omfatter; HashSet, LinkedHashSet og TreeSet. I eksemplet nedenfor vil vi se på at krydse gennem HashSet, som gemmer dets elementer i en hash-tabel.

package iterator;
import java.util.HashSet;
//import java.util.Iterator;
import java.util.Set;
public class Iterator {
    public static void main(String[] args) {
         // create a set
	Set<String> cars = new HashSet<String>();
	// add elements to he set
	cars.add("Toyota");
	cars.add("Benz");
	cars.add("Mercidez");
        cars.add("Noah");
        cars.add("Corolla");
	// get iterator over the set
	Iterator<String> iterator = cars.iterator();
	// iterate over the set
	while (iterator.hasNext()) {
		// get current element
		String element = iterator.next();
		System.out.println(element);
	}        
    }   
}

Output:

run:
Toyota
Mercidez
Benz
Noah
Corolla
BUILD SUCCESSFUL (total time: 0 seconds)

Kortiterator

Et kort i java er et objekt, der kortlægger nøgler til værdier. For et kort kan vi ikke iterere direkte. I stedet vil vi gentage dets værdisæt som vist nedenfor.

package iterator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class Iterator {
    public static void main(String[] args) {
         // create a hashmp
	Map<Integer, String> cars = new HashMap<Integer, String>();
	// add elements to the map
	cars.put(1, "Toyota");
	cars.put(2, "Benz");
	cars.put(3, "Mercidez");
    cars.put(4, "Noah");
    cars.put(5, "Corolla");
	// get iterator over map values
	Iterator<Integer> iterator = cars.keySet().iterator();
	// iterate over the set
	while (iterator.hasNext()) {
		// get current element
		Integer key = iterator.next();
		System.out.println("value:" + cars.get(key));
	}        
    }
}

Output:

run:
value:Toyota
value:Benz
value:Mercidez
value:Noah
value:Corolla
BUILD SUCCESSFUL (total time: 0 seconds)

Fra ovenstående eksempel går vi gennem kortet ved hjælp af dets nøglesæt. Hver nøgle er kortlagt til højst én værdi.

Fordele ved java Iterator

  • Kan bruges i enhver samlingsklasse
  • Den understøtter LÆS- og FJERN-operationerne
  • Dets brugervenlige metodenavne

Ulempe ved java Iterator

  • Den understøtter ikke CREATE og Update operationer
  • Understøtter ikke omvendt rækkefølge, men kun fremadgående retning

Typer af iteratorer

Vi kan også kategorisere iteratorer på to måder:fejl-hurtig iterator og fejlsikker iterator.

  • Fejl-hurtig iterator – Denne type iterator fejler, når strukturen af ​​en samling ændres, siden looping er begyndt. Med dette betyder forandring; få adgang til, tilføje, opdatere eller fjerne elementer i en samling.
  • Fejlsikker iterator – denne type iterator giver ingen undtagelse i tilfælde af nogen ændring på tidspunktet for gennemkørslen. Det fungerer på en kopi af samlingen i stedet for den originale samling.

Konklusion

I denne tutorial har vi dækket iterator i java. For at bruge iteratorer skal du importere Java.util.*-biblioteket. Dette skyldes, at en iterator er en grænseflade til util-pakken. Disse samlingsklasser inkluderer HashMap, ArrayList, LinkedList osv. Med en iterator kan du ændre disse samlingsklasser, mens du krydser. Iteratorer er også designet til at ændre samlinger nemt, de går over. 'next( )'-metoden returnerer det næste element, hasNext ( )-metoden returnerer true, er vi har næste element else returnerer false, og remove ( )-metoden fjerner elementer fra en samling, mens du looper.


Java tag