Que sont les paramètres de longueur variable en Java ? Quel est le principe de la boucle foreach ?

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

1 Vous pouvez utiliser le parcours de tableau pour parcourir des paramètres de longueur variable

<🎜. >

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 variable

String[] strs = {"000", "111", "222", "333"};
print(strs);

dans la liste des paramètres de méthode.

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);
    }
}

Peu importe si vous ne le comprenez pas. New, dup et Ensurespecial sont les instructions définies dans la table d'instructions de bytecode. La machine virtuelle exécute le code C++ spécifié. sur ces instructions et termine l’exécution de chaque fonction. La clé est de voir les lignes 21 et 22. J'ai vu un itérateur, donc je suis arrivé à la conclusion :

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;

Lors de la compilation, le compilateur comparera automatiquement pour

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!