Analyse verschiedener Verwendungen der Java for-Schleife

J2SE 1.5 bietet eine weitere Form der for-Schleife. Mit dieser Form der for-Schleife können Objekte von Typen wie Arrays und Sammlungen auf einfachere Weise durchlaufen werden. In diesem Artikel werden spezifische Möglichkeiten zur Verwendung dieser Schleife vorgestellt, erläutert, wie Sie Ihre eigenen Klassen definieren, die auf diese Weise durchlaufen werden können, und einige häufige Probleme mit diesem Mechanismus erläutert.

Wenn Sie in einem Java-Programm die Elemente in einem Array oder einer Sammlung einzeln „verarbeiten“ oder „durchlaufen“ möchten, verwenden Sie dazu normalerweise eine for-Schleife (natürlich verwenden Sie Andere Verschiedene Arten von Schleifen sind nicht unmöglich, aber ich weiß nicht, ob das daran liegt, dass das Wort „for“ relativ kurz ist oder ob die Bedeutung des Wortes „for“ für diese Art von Operation besser geeignet ist. die for-Schleife wird häufiger verwendet als andere Schleifen).

Zum Durchlaufen von Arrays wird diese Schleife im Allgemeinen wie folgt geschrieben:

Listing 1: Traditionelle Art, Arrays zu durchlaufen

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

Und zum Durchlaufen von Sammlungsobjekten wird diese Schleife so geschrieben nimmt normalerweise die Form an:

Listing 2: Traditionelle Art, Sammlungsobjekte zu durchlaufen

/* 建立一个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);
 }

In der neuesten Version der Java-Sprache, J2SE 1.5, wird eine weitere Methode in Form einer for-Schleife eingeführt. Mit Hilfe dieser Form einer for-Schleife können Sie Traversierungsarbeiten jetzt einfacher durchführen.

1. Der zweite Typ einer for-Schleife

Genau genommen hat der zweite Typ einer for-Schleife in Java grundsätzlich dieses Format:

for (Schleifenvariable vom Typ Schleifenvariable Name: zu durchlaufendes Objekt) Schleifenkörper

Mit dieser Syntax kann die Operation zum Durchlaufen eines Arrays wie folgt geschrieben werden:

Listing 3: Eine einfache Möglichkeit, ein Array zu durchqueren

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

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

Die hier verwendete for-Schleife wird während der Kompilierung in dieser Form angezeigt:

Listing 4: Äquivalenter Code für eine einfache Möglichkeit, ein Array zu durchlaufen

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

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

Das „ „Variablenname A“ ist hier ein vom Compiler automatisch generierter Name, der keine Verwirrung stiftet.

Der Vorgang des Durchlaufens einer Sammlung kann auch so geschrieben werden:

Listing 5: Eine einfache Möglichkeit, eine Sammlung zu durchqueren

 /* 建立一个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” */
 }

Die hier verwendete for-Schleife, Dann wird es während der Kompilierung in dieser Form angezeigt:

Listing 6: Äquivalenter Code für eine einfache Möglichkeit, die Sammlung zu durchlaufen

 /* 建立一个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” */
 }

Der „Variablenname B“ ist hier auch ein Compiler A Nicht verwirrender Name, der vom Compiler automatisch generiert wird.

Da der J2SE 1.5-Compiler diese Form der for-Schleife während der Kompilierung als die entsprechende traditionelle Form betrachtet, besteht kein Grund zur Sorge über Leistungsprobleme.

Der Grund dafür, dass „foreach“ und „in“ nicht verwendet werden

Java verwendet „for“ (anstelle des klareren „foreach“), um diese Art von Schleife zu steuern, die allgemein als „foreach“ bezeichnet wird „for-each“-Schleife und verwenden Sie „:“ (anstelle des expliziteren „in“), um den Namen der Schleifenvariablen und das zu iterierende Objekt zu trennen. Der Hauptgrund dafür besteht darin, Kompatibilitätsprobleme zu vermeiden, die durch die Einführung neuer Schlüsselwörter verursacht werden. In der Java-Sprache dürfen Schlüsselwörter nicht als Variablennamen verwendet werden, obwohl der Name „foreach“ verwendet wird. Nicht sehr viele, aber „in“. „ ist ein Name, der häufig zur Darstellung von Eingabeströmen verwendet wird (in der Klasse java.lang.System gibt es beispielsweise ein statisches Attribut mit dem Namen „in“, was „Standardeingabestrom“ bedeutet).

Es ist tatsächlich möglich, die Syntax geschickt so zu gestalten, dass Schlüsselwörter nur in bestimmten Kontexten eine besondere Bedeutung haben, sodass sie als gewöhnliche Bezeichner verwendet werden können. Diese Strategie, die die Grammatik verkompliziert, wurde jedoch nicht allgemein übernommen.

Die lange Geschichte der „for-each-Schleife“

Die „for-each-Schleife“ ist keine neuere Kontrollstruktur. Diese Kontrollstruktur war bereits in der Bourne-Shell (dem ersten ausgereiften UNIX-Befehlsinterpreter) enthalten, die 1979 offiziell veröffentlicht wurde (die Schleife wird durch „for“ und „in“ geführt, und der Schleifenkörper wird durch „do“ und „done“ geführt). ). ” zu identifizieren).

2. Verhindern Sie, dass Schleifenvariablen im Schleifenkörper geändert werden

Standardmäßig lässt der Compiler die Neuzuweisung von Schleifenvariablen im Schleifenkörper der zweiten for-Schleife zu. Da dieser Ansatz jedoch keine Auswirkungen auf die Situation außerhalb des Schleifenkörpers hat und leicht zu Schwierigkeiten beim Verständnis des Codes führen kann, wird er im Allgemeinen nicht empfohlen.

Java bietet einen Mechanismus zum Blockieren solcher Vorgänge während der Kompilierung. Die spezifische Methode besteht darin, einen „endgültigen“ Modifikator vor dem Schleifenvariablentyp hinzuzufügen. Auf diese Weise führt die Zuweisung eines Werts zur Schleifenvariablen im Schleifenkörper zu einem Kompilierungsfehler. Mit Hilfe dieses Mechanismus kann der absichtliche oder unbeabsichtigte Vorgang „Schleifenvariablen im Schleifenkörper ändern“ wirksam verhindert werden.

Listing 7: Neuzuweisung deaktivieren

清单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中文网！