La portée et la relation de l'Iterator et de ListIterator:
(1) Iterator peut être utilisé pour implémenter la liste d'interface itérative ArrayList, LinkedList, MAP, etc.
(2) ListIterator, comme son nom l'indique, est habitué à itérer la liste pour implémenter ArrayList et LinkedList.
(3) Comme le montre le code source ou la documentation de l'API, Iterator est la classe parent de ListIterator.
Interface publique ListIterator <E> étend Iterator <e> {// omettre ...}De nouvelles méthodes ont été ajoutées à ListIterator.
Analyse de l'instance de position de la curseur implicite de l'itérateur:
Comme le montre la figure ci-dessus, il y a quatre éléments A, B, C, D dans la liste de collecte à laquelle l'itérateur doit itérater. Lorsque la méthode xxx.iterator () ou xxx.litterator () est appelée,
L'Itérateur pointe vers la position d'Iterator_one, et lorsque la méthode xxx.next () est appelée, la position Iterator pointe vers la position iterator_two.
La position vers laquelle l'itérateur pointe n'est pas directement opposée à l'élément, mais entre les éléments.
Méthodes dans Iterator et ListIterator:
------ Méthode dans Iterator:
Résumé des méthodes officielles de l'API:
Analyse des méthodes:
Hasnext (): détermine s'il y a un élément dans la position suivante pointée par l'itérateur d'élément dans la collection. Renvoie vrai, sinon retourne false
suivant (): renvoie la valeur de l'élément suivant à la position pointée par l'itérateur.
retirer (): Retirez la valeur supprimée par l'itérateur via l'itérateur.
------ Méthode dans ListIterator:
Résumé des méthodes officielles de l'API:
Analyse des méthodes:
Add (EE): insérez un élément spécifié dans la collection. La position d'insertion est liée à la dernière opération NEXT () ou précédente ().
Si la dernière opération est suivante (), l'élément est inséré après la suppression de l'élément, et s'il est précédent (), l'élément est inséré avant la suppression de l'élément.
Hasnext (): Lorsque l'ensemble est traversé dans l'ordre positif, il détermine si l'élément suivant pointé par le curseur implicite existe. S'il existe, il renvoie vrai, sinon il renvoie faux.
Hasprevious (): Lorsque l'ensemble est traversé, il détermine si l'élément précédent du curseur implicite existe. S'il existe, il renvoie vrai, sinon il renvoie faux.
suivant (): renvoie la valeur d'élément suivante à la position pointée par le curseur implicite.
NextIndex (): renvoie la valeur d'index de l'élément suivant à la position pointée par le curseur implicite.
Pridif (): Renvoie la valeur d'élément précédente à la position pointée par le curseur implicite.
PrécédentIndex (): Renvoie la valeur d'index de l'élément de position précédent pointé par le curseur implicite.
Remove (): La suppression des éléments de la collection n'est pas de supprimer tous les éléments, mais de supprimer les éléments renvoyés par la dernière opération suivante () ou précédente ().
Si Next () ou Pridived () ne renvoie pas de valeur, une erreur sera signalée.
set (ee): Remplacez l'élément renvoyé par suivant () ou précédent () par E de la liste. Par exemple, si Next () est supprimé en tant que A, vous pouvez remplacer un par un par jeu.
Exemple 1:
package com.lanhuigu.java; import java.util.arraylist; import java.util.list; import java.util.listiterator; public class listIteratorApitest {public static void main (String [] args) {list> list = new ArrayList <string> (); list.add ("a"); list.add ("b"); list.add ("c"); list.add ("d"); // à l'heure listIterator.next (); // Supprimer l'élément ListIterator.Remove (); // Supprimer l'élément récupéré par suivant. À cette époque, A a été supprimé de la collection. Ajouter un élément // listIterator.Previous (); listIterator.add ("e"); // Avant de pointer de la position iterator_two, il s'agit de la position précédente // Imprimez l'élément récupéré par suivant. System.out.println ("FirstElement:" + PremierElement); // Relidialise la position de pointage vers la position iterator_one, mais A n'a pas été supprimé et ajoute e listIterator = list.ListeTiterator (); while (listIterator.hasnext ()) {System.out.println (listIterator.next ());} System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- list.ListIterator (); while (listIterator.hasnext ()) {System.out.println (listIterator.next ());}}Exemple 2:
package com.lanhuigu.java; import java.util.arraylist; import java.util.iterator; import java.util.list; import java.util.listiterator; public class iteratorapitest {public static void main (string [] args) {list <string> list = new ArrayList <string> (); list.add ("a"); list.add ("b"); list.add ("c"); list.add ("d"); // la première façon de traverser l'ensemble est de traverser directement les instructions de boucle (pour, do- {System.out.println (e);} System.out.println ("--------------------" "); // La deuxième façon de traverser l'ensemble (iterator) iterator <string> iterator = list.iterator (); while (iterator.hasnext ()) {System.out.println (iterator.next ());} System.out.println ("------------------------------"); // la troisième voie de traverser l'ensemble (listIterator) ListIterator <string> ListIterator = list.ListIterator (); while (listIterator.hasnext ()) {System.out.println (listIterator.next ());} System.out.println ("-------------------");}}Résumer
Ce qui précède est toutes les explications détaillées des exemples d'itérateur et de listriterator en Java. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!