devstory

Le Tutoriel de Java ListIterator

View more Tutorials:

1- ListIterator

ListIterator est une sous-interface d'Iterator. C'est l'un des moyens de parcourir (traverse) les éléments d'une List. À l'inverse d'Iterator, ListIterator prend en charge les éléments de déplacement dans les directions avant et arrière. ListIterator prend également en charge la suppression, la mise à jour ou l'insertion d'un élément pendant l'itération.
public interface ListIterator<E> extends Iterator<E>
Ci-dessous une comparaison entre Iterator et ListIterator:
IteratorListIterator
Utilisé pour parcourir les éléments d'une Collection.
Utilisé pour parcourir les éléments d'une List.
Prendre en charge des éléments vers l'avant.
Prendre en charge des éléments en direction vers l'avant et l'arrière.
Peut prendre en charge la suppression d'un élément pendant l'itération (dépendant du type de Collection)
Peut prendre en charge la suppression, la mise à jour ou l'insertion d'un élément au cours de l'itération (dépendant du type de List)
L'ordre d'itération des éléments n'est pas garanti.
L'ordre d'itération des éléments est garanti.
ListIterator methods
boolean hasPrevious()
E previous()

int nextIndex()
int previousIndex()
void set(E e) // Optional operation.
void add(E e) // Optional operation.

// Methods inherited from Iterator:
boolean hasNext()
E next();
default void remove() // Optional operation.
default void forEachRemaining(Consumer<? super E> action)

2- Example

Par exemple: Utiliser ListIterator pour parcourir les éléments d'une List:
ListIteratorEx1.java
package org.o7planning.listiterator.ex;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorEx1 {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("One");
        list.add("Two");
        list.add("Three");
        list.add("Four");

        // Create ListIterator.
        ListIterator<String> listIterator = list.listIterator();

        String first = listIterator.next();
        System.out.println("First:" + first);// -->"One"

        String second = listIterator.next();
        System.out.println("Second:" + second);// -->"Two"

        if (listIterator.hasPrevious()) {
            // Take a step back
            String value = listIterator.previous();
            System.out.println("Value:" + value);// -->"Two"
        }

        System.out.println(" ----- ");

        while (listIterator.hasNext()) {
            String value = listIterator.next();
            System.out.println("value:" + value);
        }
    }
}
Output:
First:One
Second:Two
Value:Two
 -----
value:Two
value:Three
value:Four

3- remove()

Au cours de la traversée des éléments d'une Collection à l'aide d'un Iterator, vous pouvez supprimer l'élément actuel de Collection. La méthode Iterator.remove() vous permet de le faire. Cependant, tous les Iterator(s) ne prennent pas en charge cette opération, cela dépend du type de Collection. Si elle n'est pas prise en charge, une UnsupportedOperationException sera levée.
Remarque: La méthode remove() est héritée d'Iterator.
// Optional operation
// Inherited from Iterator interface
public void remove()
Exemple: Une List contient des entiers, supprimer les éléments de la liste pour s'assurer que la liste ne comprend que des entiers incrémentiels.
ListIterator_remove_ex1.java
package org.o7planning.listiterator.ex;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIterator_remove_ex1 {
    
    public static void main(String[] args)  {
        List<Integer> list= new ArrayList<Integer>();
        
        list.add(11);
        list.add(55);
        list.add(22);
        list.add(77);
        list.add(33);
        list.add(99);
        list.add(11);
        
        ListIterator<Integer> listIter = list.listIterator();
        
        int temp = listIter.next();
        
        while(listIter.hasNext())  {
            int current = listIter.next();
            
            if(current < temp)  {
                listIter.remove();
            } else {
                temp = current;
            }
        }
        
        for(Integer value: list)  {
            System.out.println(value);
        }
    }
}
Output:
11
55
77
99

4- set(E e)

Lors du parcours des éléments d'un List à l'aide d'un ListIterator, vous pouvez mettre à jour l'élément actuel. La méthode ListIterator.set(E) vous permet de le faire. Cependant, tous les ListIterator(s) ne prennent pas en charge cette opération, cela dépend du type de List. Si elle n'est pas prise en charge, une UnsupportedOperationException sera levée.
public void set(E e)
Par exemple: Une liste (List) contient des entiers, si un élément de la list est un entier négatif, il doit être remplacé par zéro.
ListIterator_set_ex1.java
package org.o7planning.listiterator.ex;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIterator_set_ex1 {
    
    public static void main(String[] args)  {
        List<Integer> list= new ArrayList<Integer>();
        
        list.add(-111);
        list.add(555);
        list.add(-222);
        list.add(777);
        list.add(-333);
        list.add(999);
        list.add(111);
        
        ListIterator<Integer> listIter = list.listIterator();
        
        while(listIter.hasNext())  {
            int current = listIter.next();
            if(current < 0)  {
                listIter.set(0);
            }  
        }
        
        for(Integer value: list)  {
            System.out.println(value);
        }
    }
}
Output:
0
555
0
777
0
999
111
Un exemple à propos d'une liste (List) qui ne prend pas en charge l'opération de ListIterator.set:
ListIterator_set_ex2.java
package org.o7planning.listiterator.ex;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;

public class ListIterator_set_ex2 {
    
    public static void main(String[] args)  {
        List<Integer> aList = Arrays.asList(-111, 555,-222,777,-333,999,111);
        
        // UnmodifiableList
        // This list does not support "set" operation!
        List<Integer> unmodifiableList = Collections.unmodifiableList(aList);
        
        ListIterator<Integer> listIter = unmodifiableList.listIterator();
        
        int current = listIter.next();
        
        listIter.set(1000); // throw UnsupportedOperationException
    }
}
Output:
Exception in thread "main" java.lang.UnsupportedOperationException
    at java.base/java.util.Collections$UnmodifiableList$1.set(Collections.java:1353)
    at org.o7planning.listiterator.ex.ListIterator_set_ex2.main(ListIterator_set_ex2.java:21)

5- add(E e)

En parcourant les éléments d'une List à l'aide d'un ListIterator, vous pouvez insérer un élément dans List. La méthode ListIterator.add(E) vous permet de le faire. Cependant, tous les ListIterator(s) ne prennent pas en charge cette opération, cela dépend du type de List. Si elle n'est pas prise en charge, une UnsupportedOperationException sera levée.
public void add(E e);
Par exemple:
ListIterator_add_ex1.java
package org.o7planning.listiterator.ex;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIterator_add_ex1 {
    
    public static void main(String[] args)  {
        List<String> list= new ArrayList<String>();
        
        list.add("One");
        list.add("Two");
        list.add("Three");
        list.add("Four");
        list.add("Five");  
        
        ListIterator<String> listIter = list.listIterator();
        
        listIter.next(); // "One"
        listIter.next(); // "Two"
        listIter.next(); // "Three"
        listIter.previous(); // "Three"
        
        listIter.add("X1");
        
        
        for(String value: list)  {
            System.out.println(value);
        }
    }
}
Output:
One
Two
X1
Three
Four
Five
Un exemple sur une List qui ne prend pas en charge l'opération de ListIterator.add:
ListIterator_add_ex2.java
package org.o7planning.listiterator.ex;

import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;

public class ListIterator_add_ex2 {
    
    public static void main(String[] args)  {
        // Fixed-size List
        // It does not support add or set operation.
        List<String> list= Arrays.asList("One","Two","Three","Four","Five");  
        
        ListIterator<String> listIter = list.listIterator();
        
        listIter.next(); // "One"
        listIter.next(); // "Two"
        listIter.next(); // "Three"
        listIter.previous(); // "Three"
        
        listIter.add("X1"); // throw UnsupportedOperationException
    }
}
Output:
Exception in thread "main" java.lang.UnsupportedOperationException
    at java.base/java.util.AbstractList.add(AbstractList.java:153)
    at java.base/java.util.AbstractList$ListItr.add(AbstractList.java:451)
    at org.o7planning.listiterator.ex.ListIterator_add_ex2.main(ListIterator_add_ex2.java:19)

6- nextIndex()

public int nextIndex()

7- previousIndex()

public int previousIndex()

View more Tutorials:

Peut-être que vous êtes intéressé

Voici des leçons en ligne à part du site web o7planning que nous recommandons. La liste comprend des leçons en ligne et celles en promo.