Le contenu de cet article est de présenter que sont les paramètres de longueur variable en Java ? Quel est le principe de la boucle foreach ? Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.
1. Le sucre syntaxique
Le sucre syntaxique est une commodité que presque tous les langages offrent plus ou moins La syntaxe que les programmeurs doivent développer le code n'est que quelques astuces mises en œuvre par le compilateur lors de la compilation. Un bytecode spécifique ou des méthodes spécifiques sont utilisés pour traiter ces syntaxes, et les développeurs peuvent les utiliser directement et facilement. . Bien que ces sucres de syntaxe n'apportent pas d'améliorations fonctionnelles substantielles, ils peuvent améliorer les performances, améliorer la rigueur de la syntaxe ou réduire le risque d'erreurs de codage . Java fournit aux utilisateurs beaucoup de sucre syntaxique, comme les génériques, l'autoboxing, l'autounboxing, les boucles foreach, les paramètres de longueur variable, les classes internes, les classes d'énumération, les assertions, etc. 2. Paramètres de longueur variable
Parlons d'abord des paramètres de longueur variable, regardons un morceau de code :
Les paramètres de la méthode d'impression signifient que le nombre de chaînes entrantes est variable
public static void main(String[] args)
{
print("000", "111", "222", "333");
}
public static void print(String... strs)
{
for (int i = 0; i < strs.length; i++)
{
System.out.println(strs[i]);
}
}Jetez un œil aux résultats d'exécution du code : <🎜. >I Les paramètres d'entrée ont été parcourus avec succès à l'aide du parcours de tableau, ce qui illustre deux problèmes :
000 111 222 333
<🎜. >
2. Les paramètres des variables sont implémentés à l'aide de tableaux
Dans ce cas, je peux en fait écrire la fonction principale comme ceci, tout à fait d'accord : Ne serait-il pas préférable de transmettre directement un tableau ? Le problème est que la longueur du tableau doit être spécifiée. Et si je veux passer 2 chaînes cette fois et 3 chaînes la prochaine fois ?
Enfin, notez que le paramètre de longueur variable doit être le dernier paramètre de la liste des paramètres de méthode et il ne peut y avoir qu'un seul paramètre de longueur variableString[] strs = {"000", "111", "222", "333"};
print(strs);3. Principe de la boucle foreach
C'est ainsi que la boucle foreach était utilisée auparavant, ce qui m'a inspiré à étudier le principe. de la boucle foreach. La raison est qu'il y a environ deux mois, j'ai écrit moi-même une ArrayList. Je voulais utiliser une boucle foreach pour la parcourir afin de voir l'effet de l'écriture, mais une exception de pointeur nul a été signalée. Cet article décrira le principe de la boucle foreach. Tout d'abord, jetez un œil à ce morceau de code : Utilisez la boucle foreach pour parcourir cette liste. Je n'expliquerai pas le résultat, vous le savez tous. il. Jetez un œil à la façon dont Java gère cette boucle foreach. Décompilez-la avec javap :
Le contenu décompilé est important, y compris les informations de classe, les références de symboles et les informations de bytecode :
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("111");
list.add("222");
for (String str : list)
{
System.out.println(str);
}
}F:\代码\MyEclipse\TestArticle\bin\com\xrq\test21>javap -verbose TestMain.class
public static void main(java.lang.String[]); flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=4, args_size=1 0: new #16 // class java/util/ArrayList 3: dup 4: invokespecial #18 // Method java/util/ArrayList."<in it>":()V 7: astore_1 8: aload_1 9: ldc #19 // String 111 11: invokeinterface #21, 2 // InterfaceMethod java/util/List. add:(Ljava/lang/Object;)Z 16: pop 17: aload_1 18: ldc #27 // String 222 20: invokeinterface #21, 2 // InterfaceMethod java/util/List. add:(Ljava/lang/Object;)Z 25: pop 26: aload_1 27: invokeinterface #29, 1 // InterfaceMethod java/util/List. iterator:()Ljava/util/Iterator;
chacunL'utilisation de ce mot-clé se traduit par Utilisation de l'itérateur, C'est le principe de la boucle foreach. De plus, nous tirons deux autres conclusions : 1 La raison pour laquelle ArrayList peut être parcourue à l'aide de la boucle foreach est que l'ensemble de la liste ArrayList. est une sous-interface de Collection, et Collection est une sous-interface de Iterable AbstractList, la classe parent d'ArrayList, implémente correctement la méthode itérateur de l'interface Iterable. Auparavant, l'ArrayList que j'ai écrite signalait directement une exception de pointeur nul en utilisant une boucle foreach car l'ArrayList que j'ai écrite n'implémentait pas l'interface Iterable
2、任何一个集合，无论是JDK提供的还是自己写的，只要想使用foreach循环遍历，就必须正确地实现Iterable接口实际上，这种做法就是23中设计模式中的迭代器模式。
数组呢？
上面的讲完了，好理解，但是不知道大家有没有疑问，至少我是有一个疑问的：数组并没有实现Iterable接口啊，为什么数组也可以用foreach循环遍历呢？先给一段代码，再反编译：
public static void main(String[] args)
{
int[] ints = {1,2,3,4,5};
for (int i : ints)
System.out.println(i);
}同样反编译一下，看一下关键的信息：
0: iconst_2 1: newarray int 3: dup 4: iconst_0 5: iconst_1 6: iastore 7: dup 8: iconst_1 9: iconst_2 10: iastore 11: astore_1 12: aload_1 13: dup 14: astore 5 16: arraylength 17: istore 4 19: iconst_0 20: istore_3 21: goto 39 24: aload 5 26: iload_3 27: iaload 28: istore_2 29: getstatic #16 // Field java/lang/System.out:Ljav a/io/PrintStream; 32: iload_2 33: invokevirtual #22 // Method java/io/PrintStream.prin tln:(I)V 36: iinc 3, 1 39: iload_3 40: iload 4 42: if_icmplt 24 45: return
这是完整的这段main函数对应的45个字节码指令，因为这涉及一些压栈、出栈、推送等一些计算机原理性的内容且对于这些字节码指令的知识的理解需要一些C++的知识，所以就不解释了。简单对照字节码指令表之后，我个人对于这45个字节码的理解是Java将对于数组的foreach循环转换为对于这个数组每一个的循环引用。
总结：以上就是本篇文的全部内容，希望能对大家的学习有所帮助。更多相关教程请访问Java视频教程，java开发图文教程，bootstrap视频教程！
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
