Métodos principales en la interfaz ListIterator

listIterator en Java

listIterator en Java


En esta entrada vamos a ver los métodos principales en la interfaz ListIterator, así como su uso. La cual añade alguna funcionalidad y ventaja extra sobre Iterator.

¿Qué es ListIterator?

ListIterator es una extensión de Iterator que añade nueva funcionalidad para poder iterar sobre las listas. Obviamente heredará de Iterator sus métodos principales y a parte incorporar alguno nuevo que veremos a continuación.

Métodos principales de uso en la interfaz ListIterator

Para poder hacer uso de la interfaz ListIterator vamos a partir de una lista y llamar al método listIterator.

List<String> numbers = List.of("1","2");
ListIterator<String> listIterator = numbers.listIterator(items.size());

Método hasNext()

El método hasNext() que proviene de la interfaz Iterator() y sirve para comprobar si tenemos un elemento siguiente en la collection.

while(listIterator.hasNext()) {
  ......
  System.out.println(it.next());
}

Método hasPrevious() en ListIterator

El método hasPrevious() el equivalente a hasNext() pero a la inversa, comprueba si hay un elemento anterior.

while(listIterator.hasPrevious()) {
    //do something
}

previous() en ListIterator

El método previous obtiene el elemento anterior del ListIterator.

while(listIterator.hasPrevious()) {
    String previousElement = listIterator.previous();
}

Tanto hasPrevious() como previous() podrían pintar una colection en orden inverso.

Método next()

El método next() de un ListIterator nos permite ir al siguiente elemento de la Collection.

while(listIterator.hasNext()) {
  System.out.println(it.next());
}

Método nextIndex()

El método nextIndex() de ListIterator sirve para indicar el índice del elemento que es devuelto por next().

String nextIndex = numbers.get(listIterator.nextIndex());

Método previousIndex()

El método previousIndex() de ListIterator nos devuelve el índice del elemento al hacer previous().

String previousIndex = numbers.get(listIterator.previousIndex());

add() en ListIterator

El método add() en ListIterator nos permite añadir un elemento nuevo. Justo antes de ser devuelto por next() y después de previous():

listIterator.add("FOUR");

set() en ListIterator

El método set() nos permite reemplazar el elemento actual con el que estamos trabajando, es decir, reemplazamos el elemento que nos devuelve la llamada next() o previous():

String nextElement = listIterator.next();
if( "1".equals(nextElement)) {
    listIterator.set("0");
}

Método remove()

Para eliminar el elemento actual en un Iterator hacemos uso del método remove().

while(listIterator.hasNext()) {
      Integer i = listIterator.next();
      if(i < 5) {
        listIterator.remove();
      }
    }

Métodos principales en la Interfaz ListIterator

MétodoSintaxisDescripción
hasNext()boolean hasNext()  Verifica si el ListIterator tiene más elementos siguientes.
hasPrevious()boolean hasPrevious()  Verifica si el ListIterator tiene más elementos previos.
next()public E next()  Obtiene el siguiente elemento del ListIterator
previous()public E previous()  Obtiene el elemento previo del ListIterator
nextIndex()int nextIndex()  Obtiene el índice del siguiente elemento del ListIterator
previousIndex()int previousIndex()  Obtiene el índice previo del ListIterator
remove()void remove()  Elimina un elemento del ListIterator
add()void add(E  e)  Permite añadir un elemento
set()void set(E  e)  Hace un set del elemento
Métodos principales ListIterator

Conclusión

En esta entrada hemos visto los métodos principales en la interfaz ListIterator, los cuales añaden más funcionalidad a Iterator y mejora el recorrido que podemos hacer en las collections.

Si necesitas más información puedes escribirnos un comentario o un correo electrónico a refactorizando.web@gmail.com o también nos puedes contactar por nuestras redes sociales Facebook o twitter y te ayudaremos encantados!


Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *