Was sind Parameter variabler Länge in Java? Was ist das Prinzip der foreach-Schleife?

Der Inhalt dieses Artikels besteht darin, vorzustellen, was Parameter variabler Länge in Java sind. Was ist das Prinzip der foreach-Schleife? Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird Ihnen hilfreich sein.

1. Syntaktischer Zucker

Syntaktischer Zucker ist eine Annehmlichkeit, die Programmierern mehr oder weniger zur Verfügung stellt Code besteht lediglich aus einigen Tricks, die vom -Compiler implementiert werden. Zur Verarbeitung dieser Syntaxen werden bestimmte Bytecodes oder bestimmte Methoden verwendet, die Entwickler verwenden können sie direkt und bequem. Obwohl diese syntaktischen Zucker keine wesentlichen funktionalen Verbesserungen bewirken, können sie die Leistung verbessern, die Genauigkeit der Syntax verbessern oder die Wahrscheinlichkeit von Codierungsfehlern verringern . Java bietet Benutzern eine Menge Syntaxzucker, wie z. B. Generika, Autoboxing, Autounboxing, Foreach-Schleifen, Parameter variabler Länge, innere Klassen, Aufzählungsklassen, Behauptungen usw.

2. Parameter variabler LängeLassen Sie uns zunächst über Parameter variabler Länge sprechen. Schauen Sie sich einen Codeabschnitt an:

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

Die Parameter der print-Methode bedeuten, dass die Anzahl der eingehenden Strings variabel ist Schauen Sie sich die laufenden Ergebnisse des Codes an:

000
111
222
333

Ich habe Array-Traversal verwendet. Die Methode hat die Eingabeparameter erfolgreich durchlaufen, was zwei Probleme veranschaulicht:

1 Sie können die Methode zum Durchlaufen des Arrays verwenden, um die Parameter variabler Länge zu durchlaufen

2. Variable Parameter werden mithilfe von Arrays implementiertIn diesem Fall kann ich die Hauptfunktion tatsächlich so schreiben, absolut fein:

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

Wäre es nicht besser, ein Array direkt zu übergeben? Das Problem ist, dass die Länge des Arrays angegeben werden muss. Was ist, wenn ich dieses Mal 2 Strings und das nächste Mal 3 Strings übergeben möchte?

Beachten Sie abschließend, dass

der Parameter variabler Länge als letzter Parameter in der Methodenparameterliste verwendet werden muss und es nur einen Parameter variabler Länge in der Methodenparameterliste geben kann.

3. Prinzip der foreach-Schleife So wurde die foreach-Schleife früher verwendet, was mich dazu inspirierte, das Prinzip zu studieren Der Grund dafür ist, dass ich vor etwa zwei Monaten selbst eine ArrayList geschrieben habe, um sie zu durchlaufen, um die Auswirkung des Schreibens zu sehen, aber eine Nullzeigerausnahme gemeldet wurde. In diesem Artikel geht es um das Prinzip der foreach-Schleife. Schauen Sie sich zunächst diesen Code an:

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

Verwenden Sie die foreach-Schleife, um diese Liste zu durchlaufen. Ich werde das Ergebnis nicht erklären. Schauen Sie sich an, wie Java mit dieser foreach-Schleife umgeht:

F:\代码\MyEclipse\TestArticle\bin\com\xrq\test21>javap -verbose TestMain.class

Der dekompilierte Inhalt enthält Klasseninformationen, Symbolreferenzen und Bytecode-Informationen:

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;

Es spielt keine Rolle, ob Sie es nicht verstehen. New, dup und invokespecial sind ursprünglich in der Bytecode-Anweisungstabelle definierte Anweisungen. Die virtuelle Maschine führt den angegebenen C++-Code aus, um die Funktion zu vervollständigen jede Anweisung. Der Schlüssel liegt darin, die Zeilen 21 und 22 zu sehen. Ich habe einen Iterator gesehen und bin zu dem Schluss gekommen:

Während der Kompilierung vergleicht der Compiler automatisch nacheachDie Verwendung dieses Schlüsselworts bedeutet Verwendung des Iterators, Dies ist das Prinzip der foreach-Schleife. Darüber hinaus ziehen wir zwei weitere Schlussfolgerungen: 1. Der Grund, warum ArrayList mit der foreach-Schleife durchlaufen werden kann, liegt darin, dass die gesamte ArrayList-Liste vorhanden ist ist eine Unterschnittstelle von Collection, und Collection ist eine Unterschnittstelle von

Iterable. AbstractList, die übergeordnete Klasse von ArrayList, implementiert die Iteratormethode der Iterable-Schnittstelle korrekt. Zuvor hat die ArrayList, die ich selbst geschrieben habe, mithilfe einer foreach-Schleife direkt eine Nullzeigerausnahme gemeldet, da die ArrayList, die ich selbst geschrieben habe, die Iterable-Schnittstelle nicht implementiert hat

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视频教程！

Das obige ist der detaillierte Inhalt vonWas sind Parameter variabler Länge in Java? Was ist das Prinzip der foreach-Schleife?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!