Un cursor de Java es un iterador que se utiliza para iterar, atravesar o recuperar los elementos de un objeto Collection o Stream uno por uno. En este artículo, aprenderemos sobre los iteradores de Java y su funcionamiento.

Tipos de cursores en Java

Hay tres cursores en Java como se menciona a continuación:

1. Iterador
2. Enumeración
3. ListaIterador

Nota: SplitIterator también se puede considerar como un cursor, ya que es únicamente un tipo de iterador.

1. Iterador

Los iteradores en Java se utilizan en el Marco de colección para recuperar elementos uno por uno. Es un universal iterador ya que podemos aplicarlo a cualquier objeto de Colección. Al usar Iterator, podemos realizar operaciones de lectura y eliminación. Es una versión mejorada de Enumeración con la funcionalidad adicional de eliminar un elemento.

Iterator debe usarse siempre que queramos enumerar elementos en todas las interfaces implementadas en el marco de la Colección, como Set, List, Queue, Deque y todas las clases implementadas de la interfaz Map. El iterador es el solo Cursor disponible para todo el marco de la colección. Se puede crear un objeto iterador llamando al iterador() método presente en la interfaz de Colección.

Sintaxis

Iterator itr = c.  iterator  ();>

Nota: Aquí c es cualquier objeto de Colección. itr es de tipo interfaz Iterator y se refiere a c.

matriz en métodos java

Métodos de interfaz iterador en Java

La interfaz del iterador define tres métodos que se enumeran a continuación:

1. tieneSiguiente(): Devuelve verdadero si la iteración tiene más elementos.

public boolean hasNext();>

2. siguiente(): Devuelve el siguiente elemento de la iteración. arroja Ninguna excepción de elemento tal si no hay más elementos presentes.

public Object next();>

3. eliminar(): Elimina el siguiente elemento de la iteración. Este método solo se puede llamar una vez por llamada a next().

public void remove();>

Nota: eliminar() El método puede generar dos excepciones, a saber, las siguientes:

• Excepción de operación no admitida : Si la operación de eliminación no es compatible con este iterador
• Excepción de estado ilegal : Si aún no se ha llamado al siguiente método, o si ya se ha llamado al método de eliminación después de la última llamada al siguiente método.

¿Cómo funciona Java Iterator internamente?

En esta sección, intentaremos comprender cómo funcionan internamente Java Iterator y sus métodos. Tomemos el siguiente objeto LinkedList para comprender esta funcionalidad.

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

Ahora, creemos un objeto Iterador en el objeto Lista como se muestra a continuación:

Iterator citiesIterator = cities.iterator();>

El iterador de ciudadesIteartor se verá así:

Aquí el cursor del iterador apunta antes del primer elemento de la lista.

Ahora ejecutaremos el siguiente fragmento de código.

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

Cuando ejecutamos el fragmento de código anterior, el cursor del iterador apunta al primer elemento de la lista como se muestra en el diagrama anterior.

Ahora ejecutaremos el siguiente fragmento de código.

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

Cuando ejecutamos el fragmento de código anterior, el cursor del iterador apunta al segundo elemento de la lista como se muestra en el diagrama anterior. Realice este proceso para llevar el cursor del iterador al elemento final de la lista.

Después de leer el elemento final, si ejecutamos el siguiente fragmento de código, devuelve un valor falso.

citiesIterator.hasNext();>

Como el cursor del iterador apunta después del elemento final de la lista, el método hasNext() devuelve un valor falso.

Nota: Después de observar todos estos diagramas, podemos decir que Java Iterator solo admite iteración en dirección directa como se muestra en el siguiente diagrama. Por eso también se le conoce como cursor unidireccional.

Ejemplo

// 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 = nueva lista de matrices (); // Iterando sobre la Lista para (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.iterador(); // Comprobando el siguiente elemento donde // la condición se cumple hasta que haya un solo elemento // en la Lista usando el método hasnext() while (itr.hasNext()) { // Mover el cursor al siguiente elemento int i = itr.next( ); // Obteniendo elementos uno por uno System.out.print(i + ' '); // Eliminando elementos impares if (i % 2 != 0) itr.remove(); } // Comando para la siguiente línea System.out.println(); // Imprimir los elementos dentro del objeto 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]>

Iterador dividido

Los divisores, al igual que otros iteradores, sirven para atravesar los elementos de una fuente. Una fuente puede ser una Recopilación , un canal IO o una función de generador. Está incluido en JDK 8 para admitir un recorrido paralelo eficiente (programación paralela) además del recorrido secuencial. La interfaz Java Spliterator es un iterador interno que divide la secuencia en partes más pequeñas. Estas piezas más pequeñas se pueden procesar en paralelo.

Nota: En la programación de la vida real, es posible que nunca necesitemos usar Spliterator directamente. En operaciones normales, se comportará exactamente igual que Java Iterator.

Ventajas del iterador de Java

• Podemos usarlo para cualquier clase de Colección.
• Admite operaciones de lectura y eliminación.
• Es un cursor universal para API de colección.
• Los nombres de los métodos son simples y fáciles de usar.

Limitaciones del iterador de Java

Además, existen ciertas limitaciones de Iterator que se enumeran a continuación:

• En operaciones CRUD, NO admite operaciones CREAR y ACTUALIZAR.
• Solo admite iteraciones en dirección directa que sean un iterador unidireccional.
• En comparación con Spliterator, NO admite la iteración de elementos en paralelo, lo que significa que solo admite la iteración secuencial.
• En comparación con Spliterator, NO admite un mejor rendimiento para iterar grandes volúmenes de datos.

2. Enumeración

Es una interfaz que se utiliza para obtener elementos de colecciones heredadas (Vector, Hashtable). La enumeración es el primer iterador presente en JDK 1.0, los silencios se incluyen en JDK 1.2 con más funcionalidad. Las enumeraciones también se utilizan para especificar los flujos de entrada a un SecuenciaInputStream . Podemos crear un objeto de enumeración llamando elementos() método de la clase vectorial en cualquier objeto vectorial

java cómo anular

Sintaxis

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

Hay dos métodos en la interfaz de enumeración, a saber:

1. público booleano tieneMásElementos(): Este método prueba si esta enumeración contiene más elementos o no.

2. Objeto público nextElement(): Este método devuelve el siguiente elemento de esta enumeración. Lanza NoSuchElementException si no hay más elementos presentes

Ejemplo

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

Existen ciertas limitaciones de enumeración que son las siguientes:

• La enumeración es para legado clases (Vector, Hashtable) únicamente. Por tanto, no es un iterador universal.
• Las operaciones de eliminación no se pueden realizar mediante enumeración.
• Sólo es posible la iteración en dirección directa.

Similitudes entre la enumeración de Java y el iterador

• Ambos son cursores de Java.
• Ambos se utilizan para iterar una colección de elementos de objeto uno por uno.
• Ambos admiten operaciones de LECTURA o Recuperación.
• Ambos son cursores Java unidireccionales, lo que significa que solo admiten iteración en dirección directa.

Diferencias entre enumeración e iterador de Java

La siguiente tabla describe las diferencias entre Java Enumeration e Iterator:

3. ListaIterador

Solo es aplicable para clases implementadas de colección de listas como ArrayList, LinkedList, etc. Proporciona iteración bidireccional. ListIterator debe usarse cuando queremos enumerar elementos de List. Este cursor tiene más funcionalidades (métodos) que el iterador. El objeto ListIterator se puede crear llamando listaIterador() método presente en la interfaz Lista.

Sintaxis

ListIterator ltr = l.  listIterator  ();>

Nota: Aquí l es cualquier objeto Lista, ltr es de tipo. Interfaz ListIterator y se refiere a l. La interfaz ListIterator amplía la interfaz Iterator. Entonces, los tres métodos de la interfaz Iterator están disponibles para ListIterator. Además, hay seis más métodos.

1. dirección hacia adelante

1.1 tieneSiguiente(): Devuelve verdadero si la iteración tiene más elementos.

public boolean hasNext();>

1.2 siguiente(): Igual que el método next() de Iterator. Devuelve el siguiente elemento de la iteración.

public Object next();>

1.3 índicesiguiente(): Devuelve el siguiente índice de elemento o tamaño de lista si el iterador de la lista está al final de la lista.

public int nextIndex();>

2. Dirección hacia atrás

2.1 tieneAnterior(): Devuelve verdadero si la iteración tiene más elementos mientras retrocede.

public boolean hasPrevious();>

2.2 anterior(): Devuelve el elemento anterior en la iteración y puede lanzar Ninguna excepción de elemento tal si no hay más elementos presentes.

public Object previous();>

2.3 índice anterior(): Devuelve el índice del elemento anterior o -1 si el iterador de la lista está al principio de la lista,

int en cadena

public int previousIndex();>

3. Otros métodos

3.1 eliminar(): Igual que el método remove() de Iterator. Elimina el siguiente elemento de la iteración.

public void remove();>

3.2 conjunto (Objeto obj): Reemplaza el último elemento devuelto por next() o anterior() con el elemento especificado.

public void set(Object obj);>

3.3 agregar (objeto obj): Inserta el elemento especificado en la lista en la posición anterior al elemento que devolvería next()

public void add(Object obj);>

Claramente, los tres métodos que ListaIterador hereda de Iterador ( tieneSiguiente() , próximo() , y eliminar() ) hace exactamente lo mismo en ambas interfaces. El tieneAnterior() y las operaciones anteriores son análogas exactas de tieneSiguiente() y próximo() . Las primeras operaciones se refieren al elemento anterior al cursor (implícito), mientras que las segundas se refieren al elemento posterior al cursor. La operación anterior mueve el cursor hacia atrás, mientras que la siguiente lo mueve hacia adelante.

ListIterator no tiene ningún elemento actual; su posición del cursor siempre se encuentra entre el elemento que sería devuelto por una llamada a anterior() y el elemento que sería devuelto por una llamada a próximo().

sanjay dutt y

1. establecer() El método puede generar 4 excepciones.

• Excepción de operación no admitida: si la operación set no es compatible con este iterador de lista
• Excepción ClassCast: Si la clase del elemento especificado impide que se agregue a esta lista
• Argumento de excepción ilegal: Si algún aspecto del elemento especificado impide que se agregue a esta lista
• Excepción de estado ilegal: Si no se ha llamado a next ni a anterior, o se ha llamado a quitar o agregar después de la última llamada a siguiente o anterior

2. agregar() El método puede generar 3 excepciones.

• Excepción de operación no admitida: Si el método add no es compatible con este iterador de lista
• Excepción ClassCast: Si la clase del elemento especificado impide que se agregue a esta lista
• Argumento de excepción ilegal: Si algún aspecto de este elemento impide que se agregue a esta lista

Ejemplo

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

Nota: Del mismo modo, existen ciertas limitaciones con ListIterator. . Es el iterador más potente, pero solo se aplica a las clases implementadas mediante Lista, por lo que no es un iterador universal.

Puntos importantes

1. Tenga en cuenta que inicialmente, cualquier referencia de iterador apuntará al índice justo antes del índice del primer elemento de una colección.
2. No creamos objetos de Enumeration, Iterator, ListIterator porque son interfaces. Usamos métodos como elementos (), iterador (), listIterator () para crear objetos. Estos métodos tienen un anónimo. Clase interna que extiende las respectivas interfaces y devuelve este objeto de clase.

Nota: El $ El símbolo en el nombre de la clase de referencia es una prueba de que se utiliza el concepto de clases internas y se crean estos objetos de clase.

Esto se puede verificar mediante el siguiente código. Para obtener más información sobre la clase interna, consulte

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

Explicación

En Java, un iterador es una interfaz que se utiliza para recorrer una colección de objetos uno por uno. Se utiliza para recorrer cualquier estructura de datos basada en colecciones, incluidas matrices, listas, conjuntos y mapas.

Un iterador tiene tres métodos principales que se utilizan para recorrer la colección:

• hasNext(): este método comprueba si hay otro elemento en la colección sobre el que se pueda iterar.
• next(): este método devuelve el siguiente elemento de la colección.
• remove(): este método elimina el elemento actual de la colección.
  

La interfaz Iterator es parte del Java Collection Framework y está implementada por las clases que representan los diferentes tipos de colecciones.

Programa

import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayListnombres = nueva ArrayList(); nombres.add('Alicia'); nombres.add('Bob'); nombres.add('Charlie'); nombres.add('David'); // Creando un iterador para la lista de nombres Iteradoriterador = nombres.iterador(); // Iterando sobre la lista de nombres usando el iterador while (iterator.hasNext()) { String name = iterator.next(); System.out.println(nombre); } } }>

Alice Bob Charlie David>

En este ejemplo, creamos una ArrayList de cadenas y le agregamos cuatro nombres. Luego creamos un iterador para la lista usando el método iterator() de la clase ArrayList. Hemos utilizado el método hasNext() para comprobar si hay más elementos en la lista para iterar, y el método next() para obtener el siguiente elemento de la lista. Hemos impreso cada elemento usando el método System.out.println().

Usar un iterador para recorrer una colección es una forma conveniente y eficiente de iterar a través de la colección porque permite iterar sobre la colección sin conocer la estructura interna de la colección. También permite la eliminación de elementos de la colección mientras se itera sobre ella.

Ventajas del iterador en Java:

• Iterator es una interfaz simple y fácil de usar que nos permite recorrer una colección sin exponer su implementación subyacente.
• El Iterador es una forma eficaz de iterar sobre una colección, especialmente cuando tenemos una gran cantidad de datos.
• El iterador proporciona una forma segura de eliminar elementos de una colección durante la iteración sin provocar excepciones de modificación simultánea.
• La interfaz Iterator la implementan todas las clases de colección en Java, por lo que podemos usar el mismo código para iterar sobre diferentes tipos de colecciones.

Desventajas del iterador en Java:

Existen ciertas desventajas de usar Iterator en Java como se menciona a continuación:

• El Iterador es una interfaz unidireccional, lo que significa que solo podemos avanzar a través de una colección. No podemos retroceder ni saltar a un elemento concreto.
• El Iterador no es seguro para subprocesos, por lo que no podemos usarlo para iterar sobre una colección en un entorno de subprocesos múltiples sin una sincronización adecuada.
• El Iterador no proporciona ningún mecanismo para modificar elementos mientras se itera sobre una colección, aparte de eliminar elementos. Si necesitamos modificar elementos, tenemos que usar otras interfaces como ListIterator o un bucle for simple.