Tutoriel détaillé sur Iterator

Iterator est un modèle qui peut séparer le comportement de traversée des structures de données de type séquence des objets parcourus. Ensuite, je partagerai avec vous l'itérateur Java à travers cet article_Compilé par Power Node Java Academy, amis dans le besoin Pour référence,

Iterator est un modèle qui peut séparer le comportement de traversée d'une structure de données de type séquence de l'objet traversé, c'est-à-dire que nous n'avons pas besoin de nous soucier de l'apparence de la structure sous-jacente de la séquence. Tant que vous obtenez cet objet, vous pouvez parcourir l'intérieur de cet objet à l'aide d'un itérateur

1.Iterator

Java fournit un. Objet itérateur spécialisé <>Itérateur, nous pouvons implémenter cette interface pour une séquence afin de fournir un itérateur Java standard. Interface itérateurLa fonction implémentée est d'"utiliser" un itérateur.

Définition du document :

Package java.util;
 publicinterface Iterator<E> {
 boolean hasNext();//判断是否存在下一个对象元素
 E next();
 void remove();
 }
 Package java.util;  
 public interface Iterator<E> { 
   boolean hasNext();//判断是否存在下一个对象元素 
   E next(); 
   void remove(); 
 }

2 .Iterable

Java fournit également une interface Iterable après l'implémentation. Nos sous-interfaces couramment utilisées qui implémentent cette interface sont : Collection<. ;E>, Deque, List, Queue, Set, etc. La méthode iterator() de cette interface renvoie un Implémentation standard de l'itérateur. L'implémentation de cette interface permet aux objets d'être la cible d'instructions Foreach. Vous pouvez parcourir votre séquence sous-jacente via la syntaxe Foreach.

L'interface Iterable contient une méthode iterator() qui peut générer un Iterator, et l'interface Iterable est utilisée par foreach pour se déplacer dans la séquence. Ainsi, si vous créez une classe qui implémente l'interface Iterable, vous pouvez l'utiliser dans l'instruction foreach.

Définition du document :

Package java.lang; 
 import java.util.Iterator;
 public interface Iterable<T> {
 Iterator<T> iterator();
 }

Définition du document :

 Package java.lang;   
 import java.util.Iterator;  
 public interface Iterable<T> {  
   Iterator<T> iterator();  
 }

Un exemple simple d'utilisation d'Iterator

 import java.util.*; 
 publicclass TestIterator { 
 public static void main(String[] args) {
 List list=new ArrayList(); 
 Map map=new HashMap(); 
 for(int i=0;i<10;i++){ 
 list.add(new String("list"+i) ); 
 map.put(i, new String("map"+i)); 
 } 
 Iterator iterList= list.iterator();//List接口实现了Iterable接口 
 while(iterList.hasNext()){ 
 String strList=(String)iterList.next(); 
 System.out.println(strList.toString()); 
 } 
 Iterator iterMap=map.entrySet().iterator(); 
 while(iterMap.hasNext()){ 
 Map.Entry strMap=(Map.Entry)iterMap.next(); 
 System.out.println(strMap.getValue());
 }
 }
 }

Utilisation d'Iterator Exemple simple

import java.util.*;   
 public class TestIterator {   
  public static void main(String[] args) {   
    List list=new ArrayList();   
    Map map=new HashMap();   
    for(int i=0;i<10;i++){   
     list.add(new String("list"+i) );   
      map.put(i, new String("map"+i));   
    }   
    Iterator iterList= list.iterator();//List接口实现了Iterable接口   
     while(iterList.hasNext()){ 
   String strList=(String)iterList.next();   
      System.out.println(strList.toString());   
    }   
   Iterator iterMap=map.entrySet().iterator();   
    while(iterMap.hasNext()){   
     Map.Entry strMap=(Map.Entry)iterMap.next();   
      System.out.println(strMap.getValue()); 
   
    } 
  } 
 }

L'interface Iterator étendra ses fonctions en fonction de la situation dans différentes sous-interfaces, comme l'itérateur ListIterator pour List, qui ne peut être utilisé que pour accéder à diverses classes List. ListIterator peut se déplacer dans les deux sens. Ajout de previous() et d'autres méthodes

3. Iterator avec des génériques

Iterator fonctionne sur n'importe laquelle des classes de collection. les classes peuvent renvoyer un tel objet Iterator. Peut être appliqué à n’importe quelle classe.

Parce que les types d'objets qui peuvent être chargés dans les classes de collection (List, Set, etc.) sont incertains lorsqu'ils sont retirés de la collection, ils appartiennent tous à la Classe Object <. 🎜> type, ce qui prend du temps. Il sera très gênant d'effectuer une conversion forcée. Utiliser des génériques signifie indiquer à l'avance à la collection le type de collection à charger, afin qu'elle puisse être utilisée directement sans afficher la conversion de type . . C'est très pratique

4. La relation entre foreach et Iterator

pour chacun est une nouvelle

boucle. ajouté par jdk5.0 > Structure, qui peut être utilisée pour traiter chaque élément d'une collection sans tenir compte de l'index de la collection. Le format est le suivant

Définissez une

for(variable:collection){ statement; }

variable

pour stocker temporairement chaque élément de la collection et exécuter l'instruction (bloc) correspondante. La collection doit être un tableau ou un objet de classe qui implémente l'interface modifiable.
L'exemple ci-dessus utilise des génériques et forEach :

L'exemple ci-dessus utilise des génériques et forEach :

import java.util.*;
 public class TestIterator {  
 public static void main(String[] args) {
 List<String> list=new ArrayList<String> (); 
 for(int i=0;i<10;i++){ 
 list.add(new String("list"+i) ); 
 } 
 for(String str:list){
 System.out.println(str); 
 }
 }

Oui On voit que le L'avantage d'utiliser l'instruction de boucle for each est qu'elle est plus concise et moins sujette aux erreurs, et vous n'avez pas besoin de vous soucier des valeurs de début et de fin de l'indice. forEach n'est pas un mot-clé, le mot-clé est toujours for et l'instruction est implémentée par l'itérateur. La plus grande différence entre eux est la méthode remove(). Généralement, appeler

import java.util.*; 
 public class TestIterator {  
  public static void main(String[] args) {  
    List<String> list=new ArrayList<String> ();   
    for(int i=0;i<10;i++){ 
      list.add(new String("list"+i) ); 
    } 
    for(String str:list){ 
     System.out.println(str); 
    }  
 }

, supprimer

et ajouter des méthodes sont des méthodes de collections spécifiques, par exemple :

List list = new ArrayList();
list.add(...); list.remove(...);

但是，如果在循环的过程中调用集合的remove()方法，就会导致循环出错，因为循环过程中list.size()的大小变化了，就导致了错误。 所以，如果想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。forEach就是为了让用iterator循环访问的形式简单，写起来更方便。当然功能不太全,所以但如有删除操作，还是要用它原来的形式。

4 使用for循环与使用迭代器iterator的对比

采用ArrayList对随机访问比较快，而for循环中的get()方法，采用的即是随机访问的方法，因此在ArrayList里，for循环较快

采用LinkedList则是顺序访问比较快，iterator中的next()方法，采用的即是顺序访问的方法，因此在LinkedList里，使用iterator较快。从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.

而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素，而不用考虑集合类的内部实现（只要它实现了 java.lang.Iterable 接口），如果使用 Iterator 来遍历集合中元素，一旦不再使用 List 转而使用 Set 来组织数据，那遍历元素的代码不用做任何修改，如果使用 for 来遍历，那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.

【相关推荐】

1. Java免费视频教程

2. YMP在线手册

3. JAVA初级入门视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!