Der Umfang und die Beziehung von Iterator und Listiterator:
(1) Iterator kann verwendet werden, um die iterative Schnittstellenliste ArrayList, LinkedList, Map usw. zu implementieren.
(2) Listiterator wird, wie der Name schon sagt, die Liste zur Implementierung von ArrayList und LinkedList verwendet.
(3) Wie aus der Quellcode oder der API -Dokumentation ersichtlich ist, ist Iterator die übergeordnete Klasse von Listiterator.
Öffentliche Schnittstelle Listiterator <E> erweitert Iterator <e> {// weglassen ...}In ListIterator wurden neue Methoden hinzugefügt.
Analyse des Iterator -impliziten Cursorpositionsinstanz:
Wie in der obigen Abbildung gezeigt, befinden sich in der Sammelliste vier Elemente A, B, C, D, zu der der Iterator iterieren soll. Wenn die Methode xxx.iterator () oder xxx.listiterator () aufgerufen wird,,,
Der Iterator verweist auf die Position von Iterator_one und wenn die Methode xxx.next () aufgerufen wird, zeigt die Iteratorposition auf die Position iterator_two.
Die Position, auf die der Iterator zeigt, ist nicht direkt dem Element, sondern zwischen den Elementen.
Methoden in Iterator und Listiterator:
------ Methode im Iterator:
Zusammenfassung der offiziellen API -Methoden:
Methodenanalyse:
HasNext (): Bestimmt, ob in der nächsten Position ein Element vorhanden ist, das vom Element -Iterator in der Sammlung gezeigt wird. Return true, ansonsten false zurückgeben
Weiter (): Gibt den Wert des nächsten Elements an der von dem Iterator gerichteten Position zurück.
entfernen (): Entfernen Sie den vom Iterator entfernten Wert über den Iterator.
------ Methode im Listiterator:
Zusammenfassung der offiziellen API -Methoden:
Methodenanalyse:
Add (EE): Fügen Sie ein angegebenes Element in die Sammlung ein. Die Insertionsposition bezieht sich auf die letzte Operation Next () oder vorher () Methode.
Wenn die letzte Operation als nächstes () erfolgt, wird das Element nach dem Nächsten des Elements eingefügt, und wenn es vorher () ist, wird das Element vor dem Entfernen des Elements eingefügt.
HasNext (): Wenn der Satz in positiver Reihenfolge durchquert wird, wird festgelegt, ob das nächste Element, auf das der implizite Cursor besteht, darauf hingewiesen wird. Wenn es existiert, gibt es wahr, sonst gibt es falsche zurück.
HaSprevious (): Wenn der Satz umgekehrt ist, wird festgelegt, ob das vorherige Element des impliziten Cursors existiert. Wenn es existiert, gibt es wahr, sonst gibt es falsche zurück.
Weiter (): Gibt den nächsten Elementwert an der Position zurück, die vom impliziten Cursor gerichtet ist.
NEXTIDINDEX (): Gibt den Indexwert des nächsten Elements an der Position zurück, die vom impliziten Cursor gezeigt wird.
Vorheriger (): Gibt den vorherigen Elementwert an der Position zurück, die vom impliziten Cursor gerichtet ist.
VorherigerIndex (): Gibt den Indexwert des vorherigen Positionselements zurück, auf das der implizite Cursor angezeigt wird.
REMET (): Elemente aus der Sammlung löschen müssen nicht alle Elemente löschen, sondern die Elemente löschen, die durch den letzten Operation als nächstes () oder vorher () zurückgegeben wurden.
Wenn als nächstes () oder vorher () keinen Wert zurückgibt, wird ein Fehler gemeldet.
SET (EE): Ersetzen Sie das von Next () oder vorher () zurückgegebene Element durch E aus der Liste. Wenn beispielsweise als nächstes () als A herausgenommen wird, können Sie eine durch eins durch eingestellt ersetzen.
Beispiel 1:
Paket com.lanhuigu.java; import Java.util.ArrayList; importieren java.util.list; importieren java.util.listiterator; public class listIterapitest {public static void main (String [] args) {list <string> list = new ArrayList <string> (); list.add ("a"); list.add ("b"); list.add ("c"); list.add ("d"); // zu diesem Zeitpunkt verweist der Iterator auf den iterator_one -Positionsliste <string> listiterator = list.listiterator (); // // //. Die Iterator -Punkte zu The Iterator Points to the itoerator_two -Position (). listIterator.Next (); // Löschen Sie den Element ListIterator.remove (); // das von Nächste abgerufene Element löschen. Zu diesem Zeitpunkt wurde A aus der Sammlung gelöscht. Element hinzufügen // listiterator.previous (); listIterator.add ("e"); // Bevor Sie auf die Position iterator_two hinweisen, ist es die vorherige Position // Drucken Sie das von Nächste abgerufene Element. System.out.println ("FirstElement:" + FirstElement); // Die Zeigeposition zur Position iterator_one neu initialisieren, aber A wurde nicht gelöscht und füge e listiterator = list.listiterator (); while (listiterator.hasnext ()) {System.out.println (listIterator.next ());} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------/ list.listiterator ();Beispiel 2:
Paket com.lanhuigu.java; import Java.util.ArrayList; Import Java.util.iterator; Import Java.util.List; Importieren Sie java.util.listiterator; public class iteratorapitest {public static void main (String [] Argumente) {list <string> list = new New ArrayList <string> (); list.add ("a"); list.add ("b"); list.add ("c"); list.add ("d"); // Der erste Weg, um das Set direkt zu durchqueren, besteht darin, direkt durch Schleifenstatements (für, do-the-the) // for (String E: List) durch die Schleifenstatements zu durchlaufen (für (String E: List)). {System.out.println (e);} System.out.println ("--------------------"); // Der zweite Weg, den Set (Iterator) Iterator <string> iterator = list.iterator () zu durchqueren; while (iterator.hasnext ()) {System.out.println (iterator.next ());} System.out.println ("--------------------------"); // Der dritte Weg, um den Set (Listiterator) Listiterator <string> listiterator = list.listiterator () zu durchqueren; while (listIterator.hasnext ()) {System.out.println (listiterator.next ());} System.out.println ("-------------------");}}Zusammenfassen
Das obige ist die detaillierte Erklärung des Iterator- und Listiteratorbeispiels in Java. Ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!