[Java] Obtenir des éléments List / Map avec Iterator

table des matières

• en premier
• Qu'est-ce qu'Iterator?
• Itérateur basé sur une liste
• Itérateur basé sur la carte
• De l'expression générique à l'instruction étendue --Résumé
• en conclusion

en premier

Lorsque vous touchez Carte / Liste en Java,

• ** Je veux faire quelque chose pour tous les éléments de List! ** **
• ** Je souhaite traiter tous les éléments de la carte de manière itérative! ** **

Je pense qu'il y a pas mal de moments comme ça. Cet ** Iterator ** est pratique dans un tel cas.

Veuillez vous y référer car il est résumé avec le code réel.

• Veuillez lire le nom de la classe / le nom de la variable, etc. dans le code du texte, le cas échéant.
• Certaines parties omettent la notation de la méthode principale.
• Veuillez nous faire savoir s'il y a des corrections / améliorations.

Qu'est-ce que Iterator

Définition

Iterator (anglais: iterator) est une abstraction du traitement itératif pour chaque élément d'un tableau ou d'une structure de données collective similaire (collection ou conteneur) dans un langage de programmation. Dans le langage de programmation actuel, il apparaît comme un objet ou une grammaire. Dans JIS, il est traduit par un répéteur (hanpukushi). wikipedia

Comme mentionné ci-dessus, l '** interface ** pour effectuer un ** traitement itératif ** sur des ** tableaux et données similaires ** est appelée Iterator.

Méthode itératrice

Les deux méthodes suivantes sont déclarées dans la classe Iterator.

• next() --Retourne l'élément suivant du traitement itératif.
• hasNext() --Retourne true s'il y a plus d'éléments dans le processus itératif.
• remove() --Supprimer le dernier élément renvoyé par l'itérateur de la collection sous-jacente. (Opération arbitraire) ―― ~~ Vous n'avez pas à vous souvenir ~~ Vous pouvez vous souvenir

Les deux ci-dessus sont importants, et next () et hasNext () sont principalement utilisés pour le traitement itératif. Lorsque vous utilisez Iterator dans une autre classe, ** remplacez ** la méthode. "Opération arbitraire" de remove () signifie "certains objets appelés Iterator ne prennent pas en charge".

notation

Lorsqu'il est utilisé, instanciez avec le nom de l'objet ```Iterator <type d'objet de référence>

Vérifiez l'utilisation réelle dans chaque classe ci-dessous.

Itérateur de type de liste

Puisque la classe List implémente l '** interface Iteratable **, vous pouvez obtenir un objet de type Iterator simplement en appelant une méthode. Liste des détails de la classe (Oracle HP)

IteratorDemo.java

public void IteratorDemo(){
//Création de liste
	List<String> list = new ArrayList<String>(); 
	list.add("Chien");                           
	list.add("singe");                           
	list.add("faisan");                                                
//Obtenir l'itérateur, appeler la méthode
	Iterator<String> itList = list.iterator();
//afficher
	while (itList.hasNext()){                    
		String s = itList.next();
		System.out.println(s);
	}
}

Résultat d'exécution:
Chien
singe
faisan

Itérateur basé sur la carte

Puisque ** l'interface Iterator n'est pas implémentée dans la classe Map **, récupérez Iterator après en avoir fait un objet de type classe qui implémente une fois l'interface Iterator.

IteratorDemo.java

//Création de carte//                                                                             
	Map<Character, String> map = new HashMap<Character, String>();                      
	map.put('A', "Arufa");                                                               
	map.put('B', "Bravo");                                                               
	map.put('C', "Charlie");                                                              
                                                                                        
//Obtenir l'itérateur, appeler la méthode//                                                                                        
	// keySet()Obtenez la liste de clés en tant qu'objet de type Set avec
	Iterator<Character> itMapKey = map.keySet().iterator();                             
                                                                                        
	// values()Obtenir une liste de valeurs en tant qu'objet de type Collection avec
	Iterator<String> itMapValue = map.values().iterator();                              
                                                                                        
	// entrySet()Avec ensemble<Map.Entry<K, V>Obtenir la combinaison clé / valeur comme objet type
	Iterator<Map.Entry<Character, String>> itEntry = map.entrySet().iterator();         
                                                                                        
                                                                                        
//afficher//                                                                                
	while (itMapKey.hasNext()){                                                         
		char key = itMapKey.next();                                                     
		System.out.println(key);                                                        
	}                                                                                   
                                                                                
	while (itMapValue.hasNext()){                                                       
		String value = itMapValue.next();                                               
		System.out.println(value);                                                      
	}                                                                                   
                                                                               
	while(itEntry.hasNext()){                                                           
		Map.Entry<Character, String> entry = itEntry.next();                            
		System.out.println(entry);                                                      
	}                                                                                                                                    

Résultat d'exécution:
A
B
C
Arufa
Bravo
Charlie
A=Arufa
B=Bravo
C=Charlie

De l'expression générique à l'instruction étendue

Dans l'exemple de code ci-dessus, la sortie a été effectuée à l'aide des génériques ** "<>" **, mais l'instruction for étendue peut également être utilisée. La méthode de sortie pour chaque instruction List / Map for est la suivante.

//Le résultat de l'affichage est le même que le code de la section "Itérateur basé sur la carte".

//Afficher tout le contenu de la liste
for (String value : list){    
	System.out.println(value);
}                             
//Afficher toutes les touches de la carte
for (char key : map.keySet()){ 
	System.out.println(key);   
}
//Afficher toutes les valeurs de la carte
for (String value : map.values()){ 
	System.out.println(value);     
}
//Combinaison clé / valeur de mappage(entrée)Afficher tout
for (Map.Entry<Character, String> entry : map.entrySet()){
	System.out.println(entry);                            
}                                                                                                                   

Résumé

La classe --List peut utiliser Iterator tel quel La classe --Map est utilisée après la conversion de la valeur en un objet du type que Iterator est implémenté.

• Les méthodes utilisées pour récupérer chaque valeur du système de carte sont les suivantes.

À la fin

Merci d'avoir lu jusqu'ici.

Il y a certaines parties qui n'ont pas encore été abordées, alors j'aimerais les résumer un jour.

J'ai vu des articles comme "Implémenter Iterator dans ma propre classe", je voudrais donc résumer cela un jour.

Puis.