1. Amélioration de la vue d'ensemble
Enhanced pour la boucle, également appelée boucle FOREAK, est utilisé pour traverser les tableaux et les conteneurs (classes classes). Lorsque vous utilisez FOREACH pour parcourir les tableaux et les éléments de collecte, il n'est pas nécessaire d'obtenir le tableau et la longueur de collecte, pas besoin d'accéder aux éléments du tableau et aux éléments de collecte basés sur l'index, ce qui améliore considérablement l'efficacité et le code est beaucoup plus simple.
2. L'explication du site officiel d'Oracle
Alors, quand devriez-vous utiliser la boucle for-out? Chaque fois que vous le pouvez. Il est vraiment beau votre code. Malheureusement, vous ne pouvez pas l'utiliser partout. Considérez, par exemple, la méthode d'expurg. Le programme a besoin d'accéder à l'itérateur afin de supprimer l'élément actuel. La boucle For-out cache l'itérateur, vous ne pouvez donc pas appeler Supprimer. Par conséquent, la boucle pour chaque fois n'est pas utilisable pour le filtrage. De même, il n'est pas utilisable pour les boucles où vous devez remplacer les éléments dans une liste ou un tableau lorsque vous la traversez. Enfin, il n'est pas utilisable pour les boucles qui doivent itérer sur plusieurs collections en parallèle. Ces lacunes étaient connues par les concepteurs, qui ont pris une décision de conscience d'aller avec une construction simple et simple qui couvrirait la grande majorité des cas.
Alors, quand devriez-vous utiliser la boucle for-out? C'est OK à tout moment. Cela embellit vraiment votre code. Malheureusement, vous ne pouvez l'utiliser nulle part. Considérez ces situations, par exemple, la méthode de suppression. Afin de supprimer l'élément actuel, le programme doit accéder à l'itérateur. La boucle For-out cache l'itérateur, vous ne pouvez donc pas appeler la fonction de suppression. Par conséquent, les boucles pour chaque fois ne conviennent pas aux éléments de filtrage. De plus, les boucles qui doivent remplacer les éléments lors de l'itération d'une collection ou d'un tableau ne sont pas applicables. Enfin, il ne convient pas à l'utilisation de la boucle parallèle dans plusieurs itérations de collection. Les concepteurs doivent comprendre ces défauts et concevoir consciemment une structure propre et simple pour éviter ces situations. Si vous êtes intéressé, vous pouvez consulter l'API du site officiel. Si vous ne savez pas comment trouver l'API sur le site officiel, veuillez cliquer pour ouvrir le site officiel pour afficher la méthode de l'API.
3. Améliorez le format pour
for (Type Nom de la variable de la collection ou de l'élément de tableau: objet de collection ou objet de tableau) {instruction Java qui fait référence au nom de la variable;}Explication officielle du site Web:
pour (Timertask t: c)
t.cancel ();
Lorsque vous voyez le côlon (:) lisez-le comme «in». La boucle ci-dessus se lit comme «pour chaque Timertasch t en c.» Comme vous pouvez le voir, la construction For-out se combine magnifiquement avec les génériques. Il préserve toute la sécurité des types, tout en supprimant l'encombrement restant. Parce que vous n'avez pas à déclarer l'itérateur, vous n'avez pas à fournir une déclaration générique pour cela. (Le compilateur fait cela pour vous derrière votre dos, mais vous n'avez pas besoin de vous en vous inquiéter.)
Le sens général est:
Quand vous voyez le côlon (:), il lit "Entrez". La boucle ci-dessus se lit comme suit "Voyager chaque élément Tirmertasch en c." Comme vous pouvez le voir, la structure For-Een est parfaitement combinée avec des génériques. Il conserve tous les types de sécurité tout en supprimant la confusion restante. Parce que vous n'avez pas à déclarer l'itérateur, vous n'avez pas à lui fournir une déclaration générique. (Le compilateur l'a fait derrière vous, vous n'avez pas besoin de s'en soucier.)
Une expérience simple:
1. Amélioration des tableaux de traversée
package cn.jason01; // amélioré pour le tableau de traverse classe publique FORTEST01 {public static void main (String [] args) {int [] array = {1,2,3}; for (int élément: array) {System.out.println (élément); }}}2. Amélioration des collections de traversée
package cn.jason01; import java.util.arraylist; public class Fortest {public static void main (string [] args) {// inférence générique, vous pouvez écrire ou ne pas écrire String arrayList <string> array = new ArrayList (); array.add ("a"); array.add ("b"); array.add ("c"); for (String String: array) {System.out.println (String); }}}4. Améliorer le principe sous-jacent de
Regardez d'abord le code
Package CN.Jason01; Importer java.util.arrayList; Importer java.util.iterator; / ** * amélioré pour le principe sous-jacent * * @author Cassandra * @version 1.1 * / public class Forest {public static void main (String [] args) {// Generic Inference, vous pouvez écrire plus tard ou non. Certaines spécifications doivent être écrites. ArrayList <string> array = new ArrayList (); // Ajouter un élément array.add ("a"); array.add ("b"); array.add ("c"); // améliorer pour l'implémentation System.out.println ("----- amélioré pour ----"); pour (chaîne de chaîne: array) {System.out.println (String); est, le principe d'implémentation sous-jacent System.out.println ("--- Compile inverse ----"); String String; pour (iterator iterator = array.iterator (); iterator.hasnext (); system.out.println (string)) {string = (string) iterator.next ();} // iterator implémente System.out.println ("------------"); for (iterator <string> i = array.iterator (); i.hasnext (); system.out.println (i.next ()))) {} // ordinaire pour implémenter System.out.println ("-----------"); pour (int x = 0; x <array.size (); x ++) {System.out.println (array.get (x));}}}D'après le code ci-dessus, nous pouvons voir que la couche sous-jacente est implémentée par les itérateurs, et l'amélioration pour réellement cache l'itérateur, donc le code naturel est beaucoup plus simple sans créer des itérateurs. C'est également la raison pour laquelle l'amélioration est lancée, qui est de réduire le code, de faciliter la traversée des collections et des tableaux et d'améliorer l'efficacité.
Remarque: Parce que l'amélioration des itérateurs mange, lorsque vous utilisez l'amélioration pour la traversée des collections et des tableaux, vous devez d'abord déterminer s'il est nul, sinon une exception de pointeur nulle sera lancée. La raison est très simple. La couche sous-jacente doit utiliser un tableau ou un objet de collecte pour appeler la méthode Iterator () pour créer un iterator (l'itérateur Iterator est une interface, il doit donc être implémenté avec une sous-classe). S'il est nul, une exception sera certainement lancée.
5. Améliorer l'applicabilité et les limites de pour
1. Applicabilité
Convient à la traversée des collections et des tableaux.
2. Limites:
① L'ensemble ne peut pas être nul car la couche sous-jacente est un itérateur.
② L'itérateur est caché, donc la collection ne peut pas être modifiée (ajoutée et supprimée) lors de la traversée de la collection.
③Cannot des marques d'angle de réglage.
6. Explication détaillée de l'utilisation de l'amélioration pour
1. Utilisation améliorée pour les tableaux
package cn.jason05; import java.util.arraylist; import java.util.list; / ** * amélioré pour l'utilisation * * @author Cassandra * / public class fordemo {public static void main (String [] args) {// Travel the Array int [] arr = {1, 2, 3, 4, 5}; pour (int x: arr) {System.out.println (x); }}}2. Améliorer l'utilisation de pour les collections
package cn.jason05; import java.util.arraylist; import java.util.list; / ** * amélioré pour l'utilisation * * @author Cassandra * / public class fordemo {public static void main (string [] args) {// travers the collection arrayList <string> array = New ArrayList <Ratt> (); array.add ("bonjour"); array.add ("monde"); array.add ("java"); pour (String s: array) {System.out.println (s); } // L'ensemble est null, lance un nullpointerException null pointer exception list <string> list = null; if (list! = null) {for (String s: list) {System.out.println (s); }} // Améliorez l'addition ou la modification des éléments pour, jetez une exception modifiée simultanément modifiée pour (String x: Array) {if (array.contains ("java")) array.add (1, "love"); }}3. La combinaison parfaite de génériques et d'amélioration pour
Remarque: il doit être parfaitement combiné avec des génériques, sinon vous devez transformer manuellement vers le bas.
1. Aucun effet générique, ne peut pas utiliser d'amélioration pour
Classe étudiante
package cn.jason01; étudiant de classe publique {private String name1; Nom de chaîne privée 2; Student public () {super (); } public Student (String name1, String name2) {super (); this.name1 = name1; this.name2 = name2; } public String getName1 () {return name1; } public void setName1 (String name1) {this.name1 = name1; } public String getName2 () {return name2; } public void setName2 (String name2) {this.name2 = name2; }}Code de test
package cn.jason01; importer java.util.arraylist; import java.util.iterator; import java.util.list; public class test02 {public static void main (string [] args) {// créer set 1 list list1 = new ArrayList (); list1.add ("a"); list1.add ("b"); list1.add ("c"); // crée set 2 list list2 = new ArrayList (); list2.add ("d"); list2.add ("e"); list2.add ("f"); // créer set trois list list3 = new ArrayList (); // traverse les premier et deuxième ensembles et ajouter des éléments pour définir trois pour (iterator i = list1.iterator (); i.hasnext ();) {// system.out.println (i.next ()); String S = (String) i.next (); pour (iterator j = list2.Iterator (); j.hasnext ();) {// list2.add (New Student (S, J.Next ())); String ss = (String) J.Next (); list3.Add (New Student (S, SS)); }} // Traversé le jeu trois et sortit l'élément Student st; pour (iterator k = list3.iterator (); k.hasnext (); System.out .println (new StringBuilder (). APPEND (St.GetName1 ()). APPEND (St.GetName2 ()))) {ST = (Student) K.next (); }}}Si le code ci-dessus supprime les deux lignes du commentaire, le programme rapportera une erreur, car la collection ne déclare pas quel type l'élément est, et l'itérateur ne sait naturellement pas de quel type il s'agit. Donc, s'il n'y a pas de génériques, alors vous devez transformer vers le bas, vous ne pouvez utiliser que des itérateurs, pas des améliorations.
2. génériques et améliorations pour
Modifier le code ci-dessus
Package CN.Jason01; Importer java.util.arraylist; Importer Java.util.iterator; Importer Java.util.list; / ** * Améliorer la combinaison parfaite de pour et génériques * * @author Cassandra * / public class test03 {public static void Main (string [] args) {// créer 1 liste <String> list1 = lid refect <> (); list1.add ("a"); list1.add ("b"); list1.add ("c"); // Create set 2 list <string> list2 = new ArrayList <string> (); list2.add ("d"); list2.add ("e"); list2.add ("f"); // créer set trois liste <Student> list3 = new ArrayList <Student> (); //// Traverse les premier et deuxième ensembles et ajouter des éléments pour définir trois pour (String S1: list1) {for (String S2: list2) {list3.add (new Student (S1, S2)); }} // Traverse les éléments de la première et de sortie pour (Student ST: List3) {System.out.println (new StringBuilder (). APPEND (St.GetName1 ()). APPEND (St.GetName2 ())); }}}4. Quatre méthodes de traction de collecte de listes
Il existe la méthode Iterator () dans l'interface de collection, qui renvoie le type d'itérateur et a un itérateur en tant qu'Itérateur. Il existe une méthode ListIterator () dans la liste, il existe donc un listiterator de collection supplémentaire. Ses sous-classes LinkedList, ArrayList et Vector implémentent toutes les interfaces de liste et de collecte, afin que vous puissiez tous utiliser deux itérateurs pour traverser.
Tests de code
package cn.jason05; import java.util.arraylist; import java.util.iterator; import java.util.list; import java.util.lititerator; / ** * il s'agit de quatre méthodes de tractionnement. * @Author Cassandra * / classe publique FORDEMO01 {public static void main (String [] args) {// Créer une liste de collection <string> list = new ArrayList <string> (); list.add ("bonjour"); list.add ("monde"); list.add ("java"); // Méthode 1, iterator iterator Traversal iterator <string> i = list.iterator (); while (i.hasnext ()) {String s = i.next (); System.out.println (s); } // Méthode 2, ListeTiterator Iterator Collection ListIterator <string> lt = list.ListIterator (); while (lt.hasnext ()) {String ss = lt.next (); System.out.println (SS); } // Méthode 3, ordinaire pour la collection de traversée pour (int x = 0; x <list.size (); x ++) {String sss = list.get (x); System.out.println (SSS); } // Méthode 4, améliorer pour la collection de traversée pour (String SSSS: list) {System.out.println (SSS); }}}5.Set de la méthode de traversée de collecte en 2
Étant donné que la collection de set n'a pas de méthode GET (int index), il n'y a pas d'ordinaire pour Loop, il n'y a pas de méthode ListeTiterator () dans l'ensemble, il n'y a donc pas d'itérateur ListIterator. Il n'y a donc que deux façons de traverser.
Tests de code
package cn.jason05; import java.util.hashset; import java.util.iterator; import java.util.set; public class forforSest03 {public static void main (string [] args) {set <string> set = new hashset <string> (); set.add ("bonjour"); set.add ("monde"); set.add ("java"); // Méthode 1, iterator iterator iterator it = set.iterator (); while (it.hasnext ()) {System.out.println (it.next ()); } // Méthode 2, améliorer pour la collection de traversée pour (String S: set) {System.out.println (s); }}}7. Résumé
1. Améliorer l'applicabilité et les limites de pour
Applicabilité: applicable aux traversées des collections et des tableaux.
limitation:
① L'ensemble ne peut pas être nul car la couche sous-jacente est un itérateur.
② La marque d'angle ne peut pas être définie.
③La itérateur est cachée, donc la collection ne peut pas être modifiée (ajoutée et supprimée) lors de la traversée de la collection.
2. Ce n'est qu'en améliorant la combinaison de pour et des génériques dans la collection que le rôle de nouvelles fonctionnalités peut être joué.
3. Il est très important de voir les nouvelles fonctionnalités du site officiel. Vous devez connaître la raison et la raison. Ce n'est qu'en le sachant dans votre cœur que vous pouvez l'utiliser librement.
Le résumé le plus complet de l'utilisation de la boucle FOR dans l'article ci-dessus "Java New Fonges" est tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.