Un Cursor Java este un Iterator, care este folosit pentru a repeta sau a parcurge sau a prelua elementele unui obiect Colecție sau Stream unul câte unul. În acest articol, vom afla despre iteratorii Java și funcționează.

Tipuri de cursore în Java

Sunt trei cursore în Java, așa cum se menționează mai jos:

1. Iterator
2. Enumerare
3. ListIterator

Notă: SplitIterator poate fi considerat și ca un cursor, deoarece este doar un tip de Iterator.

1. Iterator

Iteratorii în Java sunt utilizați în Cadrul de colectare pentru a recupera elementele unul câte unul. Este un universal iterator, deoarece îl putem aplica oricărui obiect Collection. Folosind Iterator, putem efectua atât operații de citire, cât și operații de eliminare. Este o versiune îmbunătățită a Enumerării cu funcționalitatea suplimentară de a elimina un element.

Iteratorul trebuie folosit ori de câte ori dorim să enumerăm elemente în toate interfețele implementate în cadrul Collection, cum ar fi Set, List, Queue, Deque și toate clasele implementate de interfață Map. Iteratorul este numai cursorul disponibil pentru întregul cadru de colecție. Un obiect iterator poate fi creat apelând la iterator() metoda prezentă în interfața Collection.

Sintaxă

Iterator itr = c.  iterator  ();>

Notă: Aici c este orice obiect Collection. itr este de tip interfață Iterator și se referă la c.

constructor python

Metode de interfață Iterator în Java

Interfața iteratorului definește Trei metodele enumerate mai jos:

1. areNext(): Returnează adevărat dacă iterația are mai multe elemente.

public boolean hasNext();>

2. următorul(): Returnează următorul element din iterație. Aruncă NoSuchElementException dacă nu mai este prezent niciun element.

public Object next();>

3. elimina (): Elimină următorul element din iterație. Această metodă poate fi apelată o singură dată pe apel la next().

public void remove();>

Notă: elimina() metoda poate arunca două excepții și anume după cum urmează:

• UnsupportedOperationException : Dacă operația de eliminare nu este acceptată de acest iterator
• IllegalStateException : Dacă următoarea metodă nu a fost încă apelată sau metoda remove a fost deja apelată după ultimul apel la următoarea metodă.

Cum funcționează Java Iterator intern?

În această secțiune, vom încerca să înțelegem cum funcționează intern Java Iterator și metodele sale. Să luăm următorul obiect LinkedList pentru a înțelege această funcționalitate.

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

Acum, să creăm un obiect Iterator pe obiectul Listă, așa cum se arată mai jos:

Iterator citiesIterator = cities.iterator();>

Iteratorul citisIteartor va arăta astfel -

câini de raft

Aici Cursorul lui Iterator indică înaintea primului element al Listei.

Acum, vom rula următorul fragment de cod.

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

Când rulăm fragmentul de cod de mai sus, Cursorul lui Iterator indică primul element din listă, așa cum se arată în diagrama de mai sus.

Acum, vom rula următorul fragment de cod.

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

Când rulăm fragmentul de cod de mai sus, Cursorul lui Iterator indică al doilea element din listă, așa cum se arată în diagrama de mai sus. Faceți acest proces pentru a ajunge la Cursorul Iteratorului la elementul final al Listei.

După citirea elementului final, dacă rulăm fragmentul de cod de mai jos, acesta returnează o valoare falsă.

citiesIterator.hasNext();>

Pe măsură ce Cursorul lui Iterator indică după elementul final al Listei, metoda hasNext() returnează o valoare falsă.

Notă: După ce am observat toate aceste diagrame, putem spune că Java Iterator acceptă numai Forward Direction Iteration, așa cum se arată în diagrama de mai jos. Deci este cunoscut și sub numele de Cursor unidirecțional.

Exemplu

// 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 = noua ArrayList (); // Repetarea listei pentru (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.iterator(); // Verificarea următorului element în care // condiția este valabilă până când există un singur element // în Listă folosind metoda hasnext() while (itr.hasNext()) { // Mută ​​cursorul la următorul element int i = itr.next( ); // Obținerea elementelor unul câte unul System.out.print(i + ' '); // Eliminarea elementelor impare if (i % 2 != 0) itr.remove(); } // Comandă pentru următoarea linie System.out.println(); // Imprimarea elementelor din interiorul obiectului System.out.println(al); } }>>>  
  Ieșire  
[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
Spliteratoarele, ca și alte iteratoare, sunt pentru a traversa elementele unei surse. O sursă poate fi a  Colectie  , un canal IO sau o funcție de generator. Este inclus în JDK 8 pentru sprijinirea unei traversări paralele eficiente (programare paralelă) în plus față de traversarea secvențială. Interfața Java Spliterator este un iterator intern care împarte fluxul în părți mai mici. Aceste piese mai mici pot fi prelucrate în paralel.
  
    Notă:    În programarea din viața reală, s-ar putea să nu fie nevoie să folosim Spliterator direct. În operațiuni normale, se va comporta exact la fel ca Java Iterator.
 
Avantajele Java Iterator
Îl putem folosi pentru orice clasă Collection.
Acceptă atât operațiunile READ cât și REMOVE.
Este un API Universal Cursor for Collection.
Numele metodelor sunt simple și ușor de utilizat.
Limitările Java Iterator
De asemenea, există anumite limitări ale Iterator, care sunt enumerate după cum urmează:
 
În operațiunile CRUD, NU acceptă operațiunile CREATE și UPDATE.
Acceptă numai iterația direcției înainte care este un iterator unidirecțional.
În comparație cu Spliterator, NU acceptă elemente de iterare paralelă, ceea ce înseamnă că acceptă doar iterația secvențială.
În comparație cu Spliterator, NU acceptă performanțe mai bune pentru a repeta volume mari de date.
2. Enumerare
Este o interfață folosită pentru a obține elemente ale colecțiilor vechi (Vector, Hashtable). Enumerarea este primul iterator prezent din JDK 1.0, resturile sunt incluse în JDK 1.2 cu mai multe funcționalități. Enumerările sunt, de asemenea, folosite pentru a specifica fluxurile de intrare la a    SequenceInputStream    . Putem crea un obiect Enumerare prin apelare    elemente()    metoda clasei vectoriale pe orice obiect vectorial
 
    Sintaxă    

Sunt Două metode din interfața de enumerare și anume:

1. boolean public hasMoreElements(): Această metodă testează dacă această enumerare conține sau nu mai multe elemente.

2. obiect public nextElement(): Această metodă returnează următorul element al acestei enumerații. Aruncă NoSuchElementException dacă nu mai este prezent niciun element

Exemplu

// 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>

Există anumite limitări ale enumerarii, care sunt după cum urmează:

• Enumerarea este pentru moştenire numai clase (Vector, Hashtable). Prin urmare, nu este un iterator universal.
• Operațiile de eliminare nu pot fi efectuate utilizând Enumerare.
• Este posibilă doar iterarea direcției înainte.

Asemănări între Java Enumeration și Iterator

• Ambele sunt cursore Java.
• Ambele sunt folosite pentru a repeta o colecție de elemente de obiect unul câte unul.
• Ambele suportă operațiunea READ sau Retrieval.
• Ambele sunt cursore Java unidirecționale, ceea ce înseamnă că acceptă numai iterația direcției înainte.

Diferențele dintre Java Enumeration și Iterator

Următorul tabel descrie diferențele dintre Java Enumeration și Iterator:

3. ListIterator

Este aplicabil numai pentru clasele implementate în colecția Listă, cum ar fi ArrayList, LinkedList etc. Oferă iterație bidirecțională. ListIterator trebuie folosit atunci când dorim să enumerăm elemente din List. Acest cursor are mai multe funcționalități (metode) decât iteratorul. Obiectul ListIterator poate fi creat prin apelare listIterator() metoda prezentă în interfața Listă.

Sintaxă

ListIterator ltr = l.  listIterator  ();>

Notă: Aici l este orice obiect Listă, ltr este de tip. Interfața ListIterator și se referă la l. Interfața ListIterator extinde interfața Iterator. Deci, toate cele trei metode ale interfeței Iterator sunt disponibile pentru ListIterator. În plus, există şase mai multe metode.

1. Direcția înainte

1.1 areNext(): Returnează adevărat dacă iterația are mai multe elemente

public boolean hasNext();>

1.2 următorul(): La fel ca metoda next() a Iteratorului. Returnează următorul element din iterație.

public Object next();>

1.3 următorulIndex(): Returnează următorul index al elementului sau dimensiunea listei dacă iteratorul de listă se află la sfârșitul listei.

public int nextIndex();>

2. Direcția înapoi

2.1 are Previous(): Returnează adevărat dacă iterația are mai multe elemente în timp ce parcurge înapoi.

public boolean hasPrevious();>

2.2 anterior(): Returnează elementul anterior în iterație și poate arunca NoSuchElementException dacă nu mai este prezent niciun element.

public Object previous();>

2.3 Index anterior(): Returnează indexul elementului anterior sau -1 dacă iteratorul de listă este la începutul listei,

coada java

public int previousIndex();>

3. Alte Metode

3.1 eliminați(): La fel ca metoda remove() din Iterator. Elimină următorul element din iterație.

public void remove();>

3.2 set(Obiect obiect): Înlocuiește ultimul element returnat de next() sau previous() cu elementul specificat.

public void set(Object obj);>

3.3 adaugă (obiect obiect): Inserează elementul specificat în listă la poziția dinaintea elementului care ar fi returnat de next()

public void add(Object obj);>

În mod clar, cele trei metode care ListIterator moștenește de la Iterator ( areNext() , Următorul() , și elimina() ) fac exact același lucru în ambele interfețe. The areAnterior() iar operaţiile anterioare sunt exact analoge ale areNext() și Următorul() . Primele operațiuni se referă la elementul dinaintea cursorului (implicit), în timp ce cele din urmă se referă la elementul de după cursor. Operația anterioară mută cursorul înapoi, în timp ce următoarea îl mută înainte.

ListIterator nu are niciun element curent; poziția cursorului său se află întotdeauna între elementul care ar fi returnat de un apel către anterior() și elementul care ar fi returnat printr-un apel către Următorul().

1 set() metoda poate arunca 4 excepții.

șir de int

• UnsupportedOperationException: dacă operația setată nu este acceptată de acest iterator de listă
• ClassCastException: Dacă clasa elementului specificat împiedică adăugarea acestuia în această listă
• IllegalArgumentException: Dacă un aspect al elementului specificat îl împiedică să fie adăugat la această listă
• IllegalStateException: Dacă nu au fost apelate nici următorul, nici precedentul, sau eliminarea sau adăugarea nu au fost apelate după ultimul apel la următorul sau precedentul

2. adauga() metoda poate arunca 3 excepții.

• UnsupportedOperationException: Dacă metoda de adăugare nu este acceptată de acest iterator de listă
• ClassCastException: Dacă clasa elementului specificat împiedică adăugarea acestuia în această listă
• IllegalArgumentException: Dacă un aspect al acestui element îl împiedică să fie adăugat la această listă

Exemplu

// 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]>

Notă: În mod similar, există anumite limitări cu ListIterator . Este cel mai puternic iterator, dar este aplicabil doar pentru clasele implementate List, deci nu este un iterator universal.

Puncte importante

1. Vă rugăm să rețineți că, inițial, orice referință de iterator va indica indexul chiar înainte de indexul primului element dintr-o colecție.
2. Nu creăm obiecte de Enumeration, Iterator, ListIterator deoarece sunt interfețe. Folosim metode precum elements(), iterator(), listIterator() pentru a crea obiecte. Aceste metode au un anonimat Clasa interioară care extinde interfețele respective și returnează acest obiect de clasă.

Notă: The $ simbolul în numele clasei de referință este o dovadă că este folosit conceptul de clase interioare și că aceste obiecte de clasă sunt create.

Acest lucru poate fi verificat prin codul de mai jos. Pentru mai multe despre clasa interioară consultați

// 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>

Explicaţie

În Java, un iterator este o interfață care este folosită pentru a parcurge o colecție de obiecte unul câte unul. Este folosit pentru a itera prin orice structură de date bazată pe colecții, inclusiv matrice, liste, seturi și hărți.

Un iterator are trei metode principale care sunt folosite pentru a parcurge colecția:

• hasNext() – Această metodă verifică dacă există un alt element în colecție care poate fi repetat.
• next() – Această metodă returnează următorul element din colecție.
• remove() – Această metodă elimină elementul curent din colecție.
  

Interfața Iterator face parte din cadrul Java Collection Framework și este implementată de clasele care reprezintă diferitele tipuri de colecții.

Program

import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayListnume = new ArrayList(); names.add('Alice'); names.add('Bob'); names.add('Charlie'); names.add('David'); // Crearea unui iterator pentru lista de nume Iteratoriterator = nume.iterator(); // Iterarea peste lista de nume folosind iteratorul while (iterator.hasNext()) { String name = iterator.next(); System.out.println(nume); } } }>>>  
  Ieșire  În acest exemplu, am creat o ArrayList de șiruri și i-am adăugat patru nume. Apoi am creat un iterator pentru listă folosind metoda iterator() a clasei ArrayList. Am folosit metoda hasNext() pentru a verifica dacă există mai multe elemente în listă pentru a fi iterate, iar metoda next() pentru a obține următorul element din listă. Am imprimat fiecare element folosind metoda System.out.println().
 
Folosirea unui iterator pentru a parcurge o colecție este o modalitate convenabilă și eficientă de iterare prin colecție, deoarece permite repetarea colecției fără a cunoaște structura internă a colecției. De asemenea, permite eliminarea elementelor din colecție în timp ce se repetă peste ea.
 
Avantajele Iterator în Java:
Iteratorul este o interfață simplă și ușor de utilizat, care ne permite să traversăm o colecție fără a expune implementarea acesteia.
Iteratorul este o modalitate eficientă de a itera o colecție, mai ales atunci când avem o cantitate mare de date.
Iteratorul oferă o modalitate sigură de a elimina elemente dintr-o colecție în timpul iterației fără a provoca excepții de modificare concomitente.
Interfața Iterator este implementată de toate clasele de colecții în Java, astfel încât să putem folosi același cod pentru a itera peste diferite tipuri de colecții.
Dezavantajele Iteratorului în Java:
Există anumite dezavantaje ale utilizării Iterator în Java, așa cum este menționat mai jos:
 
Iteratorul este o interfață unidirecțională, ceea ce înseamnă că putem avansa doar printr-o colecție. Nu ne putem deplasa înapoi sau să sarim la un anumit element.
Iteratorul nu este sigur pentru fire, așa că nu îl putem folosi pentru a itera o colecție într-un mediu cu mai multe fire fără o sincronizare adecvată.
Iteratorul nu oferă niciun mecanism de modificare a elementelor în timpul iterării peste o colecție, în afară de eliminarea elementelor. Dacă trebuie să modificăm elemente, trebuie să folosim alte interfețe precum ListIterator sau un simplu for loop.