Java kursors ir iterators, ko izmanto, lai iterētu vai šķērsotu vai izgūtu kolekcijas vai straumes objekta elementus pa vienam. Šajā rakstā mēs uzzināsim par Java iteratoriem un tā darbību.

Kursoru veidi Java

Tur ir trīs kursori Java, kā minēts tālāk:

1. Iterators
2. Uzskaitījums
3. ListIterator

Piezīme: SplitIterator var uzskatīt arī par kursoru, jo tas ir tikai iteratora veids.

1. Iterators

Java iteratori tiek izmantoti Kolekcijas ietvars lai izgūtu elementus pa vienam. Tas ir universāls iterators, jo mēs to varam lietot jebkuram kolekcijas objektam. Izmantojot Iterator, mēs varam veikt gan lasīšanas, gan noņemšanas darbības. Tā ir uzlabota Enumeration versija ar elementa noņemšanas papildu funkcionalitāti.

Iterators ir jāizmanto ikreiz, kad vēlamies uzskaitīt elementus visās kolekcijas ietvara ieviestajās saskarnēs, piemēram, Set, List, Queue, Deque un visās ieviestajās Map saskarnes klasēs. Iterators ir tikai kursors ir pieejams visam kolekcijas ietvaram. Iteratora objektu var izveidot, izsaucot iterators () metode, kas atrodas kolekcijas saskarnē.

Sintakse

Iterator itr = c.  iterator  ();>

Piezīme: Šeit c ir jebkurš kolekcijas objekts. itr ir Iterator interfeisa tipa un attiecas uz c.

b+ koki

Iteratora saskarnes metodes Java

Iteratora interfeiss nosaka trīs metodes, kā norādīts zemāk:

1. hasNext(): Atgriež patiesu, ja iterācijā ir vairāk elementu.

public boolean hasNext();>

2. nākamais(): Atgriež nākamo iterācijas elementu. Tas met NoSuchElementException ja vairs nav neviena elementa.

public Object next();>

3. noņemt(): Noņem nākamo iterācijas elementu. Šo metodi var izsaukt tikai vienu reizi vienā izsaukumā uz next().

public void remove();>

Piezīme: noņemt () metode var radīt divus izņēmumus, proti:

• UnsupportedOperationException : Ja šis iterators neatbalsta noņemšanas darbību
• IllegalStateException : Ja nākamā metode vēl nav izsaukta vai noņemšanas metode jau ir izsaukta pēc pēdējās nākamās metodes izsaukšanas.

Kā Java Iterator darbojas iekšēji?

Šajā sadaļā mēs centīsimies saprast, kā Java Iterator un tā metodes darbojas iekšēji. Lai saprastu šo funkcionalitāti, izmantosim šo LinkedList objektu.

List cities = new LinkedList();  cities.add('G-1');  cities.add('G-2');  cities.add('G-3');  .  .  .  cities.add('G-n');>

Tagad izveidosim iteratora objektu saraksta objektā, kā parādīts zemāk:

Iterator citiesIterator = cities.iterator();>

CityIteartor iterators izskatīsies šādi –

Šeit Iteratora kursors ir norādīts pirms saraksta pirmā elementa.

Tagad mēs izpildīsim šādu koda fragmentu.

citiesIterator.hasNext(); citiesIterator.next();>

Palaižot iepriekš minēto koda fragmentu, iteratora kursors norāda uz pirmo elementu sarakstā, kā parādīts iepriekš redzamajā diagrammā.

Tagad mēs izpildīsim šādu koda fragmentu.

citiesIterator.hasNext(); citiesIterator.next();>

Palaižot iepriekš minēto koda fragmentu, iteratora kursors norāda uz otro elementu sarakstā, kā parādīts iepriekš redzamajā diagrammā. Veiciet šo procesu, lai sasniegtu iteratora kursoru līdz saraksta beigu elementam.

Pēc pēdējā elementa nolasīšanas, ja mēs izpildām tālāk norādīto koda fragmentu, tas atgriež nepatiesu vērtību.

citiesIterator.hasNext();>

Tā kā Iteratora kursors norāda uz saraksta pēdējo elementu, hasNext() metode atgriež nepatiesu vērtību.

Piezīme: Pēc visu šo diagrammu ievērošanas mēs varam teikt, ka Java Iterator atbalsta tikai uz priekšu virziena iterāciju, kā parādīts zemāk esošajā diagrammā. Tāpēc to sauc arī par vienvirziena kursoru.

Piemērs

// Java program to Demonstrate Iterator // Importing ArrayList and Iterator classes // from java.util package import java.util.ArrayList; import java.util.Iterator; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating an ArrayList class object // Declaring object of integer type ArrayList al = jauns ArrayList (); // Atkārtošana sarakstā (int i = 0; i< 10; i++) al.add(i); // Printing the elements in the List System.out.println(al); // At the beginning itr(cursor) will point to // index just before the first element in al Iterator itr = al.iterators(); // Pārbauda nākamo elementu, kurā // nosacījums ir patiess, līdz sarakstā ir viens elements //, izmantojot metodi hasnext() while (itr.hasNext()) { // Kursora pārvietošana uz nākamo elementu int i = itr.next( ); // Elementu iegūšana pa vienam System.out.print(i + ' '); // Nepāra elementu noņemšana if (i % 2 != 0) itr.remove(); } // Komanda nākamajai rindai System.out.println(); // Elementu drukāšana objektā System.out.println(al); } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 [0, 2, 4, 6, 8]>

SplitIterator

Sadalītāji, tāpat kā citi iteratori, ir paredzēti avota elementu šķērsošanai. Avots var būt a Kolekcija , IO kanālu vai ģeneratora funkciju. Tas ir iekļauts JDK 8, lai atbalstītu efektīvu paralēlo pārvietošanos (paralēlo programmēšanu) papildus secīgai pārvietošanai. Java Spliterator interfeiss ir iekšējs iterators, kas sadala straumi mazākās daļās. Šīs mazākās daļas var apstrādāt paralēli.

Piezīme: Reālajā dzīvē programmējot, iespējams, mums nekad nebūs tieši jāizmanto Spliterator. Parastās darbībās tas darbosies tieši tāpat kā Java Iterator.

Java Iterator priekšrocības

• Mēs to varam izmantot jebkurai kolekcijas klasei.
• Tā atbalsta gan READ, gan REMOVE darbības.
• Tas ir universāls kursors kolekcijai API.
• Metožu nosaukumi ir vienkārši un ērti lietojami.

Java Iterator ierobežojumi

Ir arī daži Iterator ierobežojumi, kas ir norādīti šādi:

noņemt pirmo rakstzīmi Excel

• Programmā CRUD Operations tas NEatbalsta darbības CREATE un UPDATE.
• Tas atbalsta tikai uz priekšu vērstu iterāciju, kas ir vienvirziena iterators.
• Salīdzinot ar Spliterator, tas NEatbalsta iterācijas elementus paralēli, kas nozīmē, ka tas atbalsta tikai secīgu iterāciju.
• Salīdzinot ar Spliterator, tas NEatbalsta labāku veiktspēju, lai atkārtotu lielu datu apjomu.

2. Uzskaitījums

Tā ir saskarne, ko izmanto, lai iegūtu mantoto kolekciju elementus (Vector, Hashtable). Uzskaitījums ir pirmais iterators no JDK 1.0, pārējās ir iekļautas JDK 1.2 ar plašāku funkcionalitāti. Uzskaitījumus izmanto arī, lai norādītu ievades plūsmas uz a SequenceInputStream . Mēs varam izveidot Uzskaitīšanas objektu, zvanot elementi () vektoru klases metode jebkuram vektoru objektam

Sintakse

// Here 'v' is an Vector class object. e is of // type Enumeration interface and refers to 'v' Enumeration e =   v  .  elements  ();>

Tur ir divi metodes uzskaitīšanas saskarnē, proti:

1. publiskais Būla irMoreElements(): Šī metode pārbauda, ​​vai šis uzskaitījums satur vairāk elementu.

2. Publisks objekts nextElement(): Šī metode atgriež nākamo šī uzskaitījuma elementu. Tas izmet NoSuchElementException, ja vairs nav neviena elementa

Piemērs

// Java program to demonstrate Enumeration // Importing Enumeration and Vector classes // from java.util package import java.util.Enumeration; import java.util.Vector; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating a vector object Vector v = new Vector(); // Iterating over vector object for (int i = 0; i < 10; i++) v.addElement(i); // Printing elements in vector object System.out.println(v); // At beginning e(cursor) will point to // index just before the first element in v Enumeration e = v.elements(); // Checking the next element availability where // condition holds true till there is a single // element // remaining in the List while (e.hasMoreElements()) { // Moving cursor to next element int i = (Integer)e.nextElement(); // Print above elements in object System.out.print(i + ' '); } } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9>

Uzskaitīšanai ir noteikti ierobežojumi, kas ir šādi:

• Uzskaitījums ir paredzēts mantojums tikai klases (vektors, hashtable). Tāpēc tas nav universāls iterators.
• Noņemšanas darbības nevar veikt, izmantojot uzskaitījumu.
• Ir iespējama tikai uz priekšu vērsta iterācija.

Java Enumeration un Iterator līdzības

• Abi ir Java kursori.
• Abi tiek izmantoti, lai vienu pēc otra atkārtotu objektu elementu kolekciju.
• Abi atbalsta READ vai Retrieval darbību.
• Abi ir vienvirziena Java kursori, kas nozīmē, ka tiek atbalstīta tikai uz priekšu vērsta iterācija.

Atšķirības starp Java Enumeration un Iterator

Šajā tabulā ir aprakstītas atšķirības starp Java Enumeration un Iterator:

3. ListIterator

Tas ir piemērojams tikai List kolekcijas ieviestajām klasēm, piemēram, ArrayList, LinkedList utt. Tas nodrošina divvirzienu iterāciju. ListIterator ir jāizmanto, ja vēlamies uzskaitīt List elementus. Šim kursoram ir vairāk funkcionalitātes (metožu) nekā iteratoram. ListIterator objektu var izveidot zvanot listIterator() metode, kas atrodas saraksta saskarnē.

Sintakse

ListIterator ltr = l.  listIterator  ();>

Piezīme: Šeit l ir jebkurš saraksta objekts, ltr ir tipa. ListIterator interfeiss un attiecas uz l. ListIterator interfeiss paplašina Iterator saskarni. Tātad visas trīs Iterator saskarnes metodes ir pieejamas ListIterator. Turklāt ir seši vairāk metožu.

1. Virziens uz priekšu

1.1 hasNext(): Atgriež patiesu, ja iterācijā ir vairāk elementu

public boolean hasNext();>

1.2 nākamais(): Tāda pati kā Iterator nākamā() metode. Atgriež nākamo iterācijas elementu.

public Object next();>

1.3 nextIndex(): Atgriež nākamā elementa indeksu vai saraksta lielumu, ja saraksta iterators atrodas saraksta beigās.

public int nextIndex();>

2. Virziens atpakaļ

2.1 hasPrevious(): Atgriež patieso, ja iterācijā ir vairāk elementu, virzoties atpakaļ.

public boolean hasPrevious();>

2,2 iepriekšējais(): Atgriež iepriekšējo iterācijas elementu un var mest NoSuchElementException ja vairs nav neviena elementa.

public Object previous();>

2.3 IepriekšējaisIndekss(): Atgriež iepriekšējo elementu indeksu vai -1, ja saraksta iterators atrodas saraksta sākumā,

java saraksts

public int previousIndex();>

3. Citas metodes

3.1 noņemt (): Tas pats, kas Iteratora noņemšanas () metode. Noņem nākamo iterācijas elementu.

public void remove();>

3.2 komplekts (Objekta objekts): Aizstāj pēdējo elementu, ko atgriež next() vai previous(), ar norādīto elementu.

public void set(Object obj);>

3.3 pievienot (Objekta objekts): Ievieto norādīto elementu sarakstā pozīcijā pirms elementa, kuru atgrieztu next()

public void add(Object obj);>

Skaidrs, ka trīs metodes, kas ListIterator manto no Iterator ( hasNext() , Nākamais() , un noņemt () ) abās saskarnēs veiciet tieši to pašu. The hasPrevious() un iepriekšējās darbības ir precīzi analogi hasNext() un Nākamais() . Pirmās darbības attiecas uz elementu pirms (netiešā) kursora, bet otrās attiecas uz elementu pēc kursora. Iepriekšējā darbība pārvieto kursoru atpakaļ, bet nākamā pārvieto uz priekšu.

"kas ir 10 no 100"

ListIterator nav pašreizējā elementa; tā kursora pozīcija vienmēr atrodas starp elementu, uz kuru tiktu atgriezts izsaukums iepriekšējais () un elements, uz kuru tiktu atgriezts zvans Nākamais().

1. set() metode var radīt 4 izņēmumus.

• UnsupportedOperationException: ja iestatīto darbību šis saraksta iterators neatbalsta
• ClassCastException: Ja norādītā elementa klase neļauj to pievienot šim sarakstam
• IllegalArgumentException: Ja kāds norādītā elementa aspekts neļauj to pievienot šim sarakstam
• IllegalStateException: Ja nav izsaukts ne nākamais, ne iepriekšējais, vai noņemt vai pievienot ir izsaukti pēc pēdējā zvana uz nākamo vai iepriekšējo

2. pievienot () metode var radīt 3 izņēmumus.

• UnsupportedOperationException: Ja pievienošanas metodi šis saraksta iterators neatbalsta
• ClassCastException: Ja norādītā elementa klase neļauj to pievienot šim sarakstam
• IllegalArgumentException: Ja kāds šī elementa aspekts neļauj to pievienot šim sarakstam

Piemērs

// Java program to demonstrate ListIterator // Importing ArrayList and List iterator classes // from java.util package import java.util.ArrayList; import java.util.ListIterator; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating an object of ArrayList class ArrayList al = new ArrayList(); // Iterating over Arraylist object for (int i = 0; i < 10; i++) // Adding elements to the Arraylist object al.add(i); // Print and display all elements inside object // created above System.out.println(al); // At beginning ltr(cursor) will point to // index just before the first element in al ListIterator ltr = al.listIterator(); // Checking the next element availability while (ltr.hasNext()) { // Moving cursor to next element int i = (Integer)ltr.next(); // Getting even elements one by one System.out.print(i + ' '); // Changing even numbers to odd and // adding modified number again in // iterator if (i % 2 == 0) { // Change to odd i++; // Set method to change value ltr.set(i); // To add ltr.add(i); } } // Print and display statements System.out.println(); System.out.println(al); } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 [1, 1, 1, 3, 3, 3, 5, 5, 5, 7, 7, 7, 9, 9, 9]>

Piezīme: Tāpat ListIterator ir noteikti ierobežojumi . Tas ir visspēcīgākais iterators, taču tas ir piemērojams tikai List ieviestajām klasēm, tāpēc tas nav universāls iterators.

Svarīgi punkti

1. Lūdzu, ņemiet vērā, ka sākotnēji jebkura iteratora atsauce norādīs uz indeksu tieši pirms kolekcijas pirmā elementa indeksa.
2. Mēs neveidojam Enumeration, Iterator, ListIterator objektus, jo tie ir saskarnes. Mēs izmantojam tādas metodes kā elementi (), iterators (), listIterator (), lai izveidotu objektus. Šīm metodēm ir anonīms Iekšējā klase kas paplašina attiecīgās saskarnes un atgriež šīs klases objektu.

Piezīme: The $ simbols atsauces klases nosaukumā ir pierādījums tam, ka tiek izmantots iekšējo klašu jēdziens un izveidoti šie klases objekti.

To var pārbaudīt, izmantojot tālāk norādīto kodu. Plašāku informāciju par iekšējo klasi skatiet

// Java program to demonstrate iterators references // Importing required classes from java.util package import java.util.Enumeration; import java.util.Iterator; import java.util.ListIterator; import java.util.Vector; // Main class public class GFG { // Main driver method public static void main(String[] args) { // Creating an object of Vector class Vector v = new Vector(); // Creating three iterators Enumeration e = v.elements(); Iterator itr = v.iterator(); ListIterator ltr = v.listIterator(); // Print class names of iterators // using getClass() and getName() methods System.out.println(e.getClass().getName()); System.out.println(itr.getClass().getName()); System.out.println(ltr.getClass().getName()); } }>

java.util.Vector java.util.Vector$Itr java.util.Vector$ListItr>

Paskaidrojums

Java versijā iterators ir interfeiss, ko izmanto, lai šķērsotu objektu kolekciju pa vienam. To izmanto, lai atkārtotu jebkuru uz kolekciju balstītu datu struktūru, tostarp masīvus, sarakstus, kopas un kartes.

Iteratoram ir trīs galvenās metodes, kas tiek izmantotas, lai pārvietotos pa kolekciju:

• hasNext() — šī metode pārbauda, ​​vai kolekcijā ir cits elements, kuru var atkārtot.
• next() – šī metode atgriež nākamo elementu kolekcijā.
• Remove() – šī metode noņem pašreizējo elementu no kolekcijas.
  

Iteratora saskarne ir daļa no Java kolekcijas ietvara, un to ievieš klases, kas pārstāv dažādu veidu kolekcijas.

Programma

import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayListnosaukumi = jauns ArrayList(); names.add('Alise'); names.add('Bob'); names.add('Čārlijs'); names.add('Dāvids'); // Iteratora izveide vārdu sarakstam Iteratorsiterators = nosaukumi.iterators(); // Vārdu saraksta atkārtošana, izmantojot iteratoru while (iterator.hasNext()) { String name = iterator.next(); System.out.println(nosaukums); } } }>

Alice Bob Charlie David>

Šajā piemērā esam izveidojuši virkņu ArrayList un pievienojuši tam četrus nosaukumus. Pēc tam esam izveidojuši saraksta iteratoru, izmantojot klases ArrayList metodi iterator(). Mēs esam izmantojuši metodi hasNext(), lai pārbaudītu, vai sarakstā ir vairāk elementu, kas jāatkārto, un metodi next(), lai iegūtu nākamo elementu sarakstā. Mēs esam izdrukājuši katru elementu, izmantojot System.out.println() metodi.

Iteratora izmantošana, lai pārvietotos pa kolekciju, ir ērts un efektīvs veids, kā atkārtot kolekciju, jo tas ļauj kolekciju atkārtot, nezinot kolekcijas iekšējo struktūru. Tas arī ļauj noņemt elementus no kolekcijas, atkārtojot to.

Iteratora priekšrocības Java:

• Iterators ir vienkāršs un ērti lietojams interfeiss, kas ļauj mums šķērsot kolekciju, neatklājot tās pamatā esošo ieviešanu.
• Iterators ir efektīvs veids, kā atkārtot kolekciju, it īpaši, ja mums ir liels datu apjoms.
• Iterators nodrošina drošu veidu, kā iterācijas laikā noņemt elementus no kolekcijas, neizraisot nekādus vienlaicīgu modifikāciju izņēmumus.
• Iteratora saskarni ievieš visas Java kolekcijas klases, tāpēc mēs varam izmantot vienu un to pašu kodu, lai atkārtotu dažādu veidu kolekcijas.

Iteratora trūkumi Java:

Iteratora izmantošanai Java programmā ir daži trūkumi, kā minēts tālāk:

• Iterators ir vienvirziena saskarne, kas nozīmē, ka mēs varam virzīties tikai uz priekšu, izmantojot kolekciju. Mēs nevaram pārvietoties atpakaļ vai pāriet uz konkrētu elementu.
• Iterators nav pavedienu drošs, tāpēc mēs nevaram to izmantot, lai iterētu kolekciju vairāku pavedienu vidē bez atbilstošas ​​sinhronizācijas.
• Iterators nenodrošina nekādu mehānismu elementu modificēšanai, atkārtojot kolekciju, izņemot elementu noņemšanu. Ja mums ir nepieciešams modificēt elementus, mums ir jāizmanto citas saskarnes, piemēram, ListIterator vai vienkārša cilpa.