Analyse de plusieurs usages de Java for loop

J2SE 1.5 fournit une autre forme de boucle for. Avec cette forme de boucle for, les objets de types tels que les tableaux et les collections peuvent être parcourus de manière plus simple. Cet article présente des manières spécifiques d'utiliser cette boucle, explique comment définir vos propres classes pouvant être parcourues de cette manière et explique certains problèmes courants liés à ce mécanisme.

Dans un programme Java, lorsque vous souhaitez "traiter" - ou "parcourir" - les éléments d'un tableau ou d'une collection un par un, vous utiliserez généralement une boucle for pour y parvenir (bien sûr, utilisez Autres Différents types de boucles ne sont pas impossibles, mais je ne sais pas si c'est parce que la longueur du mot for est relativement courte, ou parce que la signification du mot for est plus adaptée à ce type d'opération. la boucle for est plus couramment utilisée que les autres boucles).

Pour parcourir des tableaux, cette boucle s'écrit généralement comme ceci :

Listing 1 : Manière traditionnelle de parcourir des tableaux

 /* 建立一个数组 */
 int[] integers = {1， 2， 3， 4};
 /* 开始遍历 */
 for (int j = 0; j < integers.length; j++) {
     int i = integers[j];
     System.out.println(i);
 }

Et pour parcourir des objets Collection, cette boucle It prend généralement la forme :

Listing 2 : Manière traditionnelle de parcourir les objets Collection

/* 建立一个Collection */
 String[] strings = {"A"， "B"， "C"， "D"};
 Collection stringList = java.util.Arrays.asList(strings);
 /* 开始遍历 */
 for (Iterator itr = stringList.iterator(); itr.hasNext();) {
     Object str = itr.next();
     System.out.println(str);
 }

Dans la dernière version du langage Java, J2SE 1.5, une autre méthode est introduite sous la forme d'une boucle for. Avec l'aide de cette forme de boucle for, vous pouvez désormais effectuer un travail de parcours de manière plus simple.

1. Le deuxième type de boucle for

À proprement parler, le deuxième type de boucle for en Java est essentiellement dans ce format :

for (type de variable de boucle variable de boucle Nom : Objet à parcourir) Corps de la boucle

Avec cette syntaxe, l'opération de parcours d'un tableau peut s'écrire comme ceci :

Listing 3 : Une manière simple de parcourir un tableau

 /* 建立一个数组 */
 int[] integers = {1， 2， 3， 4};

 /* 开始遍历 */
 for (int i : integers) {
     System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */
 }

La boucle for utilisée ici sera vue sous cette forme lors de la compilation :

Listing 4 : Code équivalent pour une manière simple de parcourir un tableau

 /* 建立一个数组 */
 int[] integers = {1， 2， 3， 4};

 /* 开始遍历 */
 for (int 变量名甲 = 0; 变量名甲 < integers.length; 变量名甲++) {
     System.out.println(integers[变量名甲]); /* 依次输出“1”、“2”、“3”、“4” */
 }

Le " nom de variable A" voici un nom généré automatiquement par le compilateur qui ne prêtera pas à confusion.

L'opération de parcours d'une Collection peut aussi s'écrire comme ceci :

Listing 5 : Une manière simple de parcourir une Collection

 /* 建立一个Collection */
 String[] strings = {"A"， "B"， "C"， "D"};
 Collection list = java.util.Arrays.asList(strings);

 /* 开始遍历 */
 for (Object str : list) {
     System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */
 }

La boucle for utilisée ici, alors Il sera vu sous cette forme lors de la compilation :

Listing 6 : Code équivalent pour un moyen simple de parcourir Collection

 /* 建立一个Collection */
 String[] strings = {"A"， "B"， "C"， "D"};
 Collection stringList = java.util.Arrays.asList(strings);

 /* 开始遍历 */
 for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext();) {
     Object str = 变量名乙.next();
     System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */
 }

Le "nom de variable B" ici est aussi un compilateur A nom non prêtant à confusion généré automatiquement par le compilateur.

Parce que lors de la compilation, le compilateur J2SE 1.5 considérera cette forme de boucle for comme la forme traditionnelle correspondante, il n'y a donc pas lieu de s'inquiéter des problèmes de performances.

La raison pour laquelle "foreach" et "in" ne sont pas utilisés

Java utilise "for" (plutôt que le "foreach" plus clair) pour guider ce type de boucle, qui est généralement appelée "for-each" et utilisez « : » (plutôt que le « in » plus explicite) pour séparer le nom de la variable de boucle et l'objet sur lequel itérer. La principale raison de cela est d'éviter les problèmes de compatibilité causés par l'introduction de nouveaux mots-clés - dans le langage Java, les mots-clés ne peuvent pas être utilisés comme noms de variables, bien que le nom "foreach" soit utilisé. Pas beaucoup, mais "dans " est un nom souvent utilisé pour représenter les flux d'entrée (par exemple, dans la classe java.lang.System, il existe un attribut statique nommé "in", qui signifie "flux d'entrée standard").

Il est en effet possible de concevoir intelligemment la syntaxe pour que les mots-clés n'aient des significations particulières que dans des contextes spécifiques, leur permettant d'être utilisés comme des identifiants ordinaires. Cependant, cette stratégie, qui complique la grammaire, n’a pas été largement adoptée.

La longue histoire de la « boucle for-each »

La « boucle for-each » n'est pas une structure de contrôle récente. Cette structure de contrôle était déjà incluse dans le shell Bourne (le premier interpréteur de commandes UNIX mature) officiellement publié en 1979 (la boucle est guidée par "for" et "in", et le corps de la boucle est guidé par "do" et "done". ). » pour identifier).

2. Empêcher la modification des variables de boucle dans le corps de la boucle

Par défaut, le compilateur autorise la réaffectation des variables de boucle dans le corps de la seconde boucle for. Cependant, comme cette approche n’a aucun impact sur la situation en dehors du corps de la boucle et peut facilement entraîner des difficultés dans la compréhension du code, elle n’est généralement pas recommandée.

Java fournit un mécanisme pour bloquer de telles opérations lors de la compilation. La méthode spécifique consiste à ajouter un modificateur "final" devant le type de variable de boucle. De cette façon, attribuer une valeur à la variable de boucle dans le corps de la boucle provoquera une erreur de compilation. Grâce à ce mécanisme, l'opération intentionnelle ou non de « modification des variables de boucle dans le corps de la boucle » peut être efficacement empêchée.

Listing 7 : Désactivation de la réaffectation

清单10：使用和要被遍历的Collection中的元素相同类型的循环变量
Collection< String> strings = new ArrayList< String>();
 strings.add("A");
 strings.add("B");
 strings.add("C");
 strings.add("D");
 for (String str : integers) {
     System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */
 }

循环变量的类型可以是要被遍历的对象中的元素的上级类型。例如，用int型的循环变量来遍历一个byte[]型的数组，用Object型的循环变量来遍历一个Collection< String>（全部元素都是String的Collection）等。

清单11：使用要被遍历的对象中的元素的上级类型的循环变量
 String[] strings = {"A"， "B"， "C"， "D"};
 Collection< String> list = java.util.Arrays.asList(strings);
 for (Object str : list) {
     System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
 }

循环变量的类型可以和要被遍历的对象中的元素的类型之间存在能自动转换的关系。J2SE 1.5中包含了“Autoboxing/Auto-Unboxing”的机制，允许编译器在必要的时候，自动在基本类型和它们的包裹类（Wrapper Classes）之间进行转换。因此，用Integer型的循环变量来遍历一个int[]型的数组，或者用byte型的循环变量来遍历一个Collection< Byte>，也是可行的。

清单12：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量
 int[] integers = {1， 2， 3， 4};
 for (Integer i : integers) {
     System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */
 }

注意，这里说的“元素的类型”，是由要被遍历的对象的决定的――如果它是一个Object[]型的数组，那么元素的类型就是Object，即使里面装的都是String对象也是如此。

可以限定元素类型的Collection

截至到J2SE 1.4为止，始终无法在Java程序里限定Collection中所能保存的对象的类型――它们全部被看成是最一般的Object对象。一直到J2SE 1.5中，引入了“泛型（Generics）”机制之后，这个问题才得到了解决。现在可以用Collection< T>来表示全部元素类型都是T的Collection。

更多Java for循环的几种用法分析相关文章请关注PHP中文网！