Explanations of several uses of the Java for loop

This article is very suitable for beginners Java programmers, mainly to understand some of the Java for the use of the loop usage, the analysis is very detailed, come together to see.

J2SE 1.5 provides another form of a for loop. With this form of for loop, you can iterate over objects of types such as arrays and collection in a simpler way. This article describes how to use this loop in a specific way, explaining how to define a class that can be traversed like this, and explain some common issues with this mechanism.

In a Java program, to "process"-or, "traverse"-an array or an element in a collection, it is generally implemented with a for loop (of course, it is not possible to use other kinds of loops, but it is not known because the length of the word for is shorter, Or because the meaning of the word for is compared with this kind of operation, at this time the for loop is much more common than other loops.

For iterating over an array, this loop is generally written like this:

Listing 1: The traditional way to iterate through an array

/**/int[] integers = {1, 2, 3, 4/** /For (int j = 0; J < Integers.length; J + +) {     int i = integers[j];     System.out.println (i); }

For the traversal of the collection object, this loop is usually taken in this form:

Listing 2: The traditional way to traverse a collection object

/**= {"A", "B", "C", "D"=/**/For (Iterator ITR = stringlist.iterator (); Itr.hasnext ();) {     = itr.next ();     System.out.println (str); }

In the latest version of the Java language, ――j2se 1.5, another form of a for loop has been introduced. With this form of a for loop, it is now possible to traverse the work in a simpler way.

1. Second for loop

Not strictly speaking, the second type of Java for loop is basically this format:

for (loop variable type loop variable name: object to be traversed) loop body

With this syntax, an operation that iterates through an array can be written like this:

Listing 3: An easy way to iterate through an array

/**/int[] integers = {1, 2, 3, 4/** /For (int  i:integers) {     /** / }

The For loop used here is considered to be such a form during compilation:

Listing 4: Equivalent code for an easy way to iterate through an array

/**/int[] integers = {1, 2, 3, 4/** /For (int variable name a = 0; variable name armor < integers.length; variable name + +) {     /** *  }

The "variable name" is a name that is generated automatically by the compiler and does not cause confusion.

This can be done by traversing a collection operation:

Listing 5: A simple way to traverse collection

/**= {"A", "B", "C", "D"=/**/For  (Object str:list) {     /** / }

The For loop used here is considered to be the form during compilation:

Listing 6: Equivalent code for a simple way to traverse collection

/**= {"A", "B", "C", "D"=/**/For (Iterator variable name b = list.iterator (); variable name B. Hasnext ();) {     = variable name B. Next ();      /* */ }

The "variable name B" Here is also a name that is automatically generated by the compiler and does not cause confusion.

Because during compilation, the J2SE 1.5 compiler will consider this form of a for loop as the corresponding traditional form, so there is no need to worry about performance issues.

Reasons for not using "foreach" and "in"

Java uses "for" (rather than more meaningful "foreach") to guide this loop, which is generally called the "For-each Loop", and uses ":" Instead of a more meaningful "in" to split the name of the loop variable and the object to be traversed. The main reason for this is to avoid the problem of compatibility due to the introduction of new keywords-in the Java language, it is not allowed to use the keyword as a variable name, although the use of the name "foreach" is not very much, but "in" is a name that is often used to represent the input stream (for example, in the Java.lang.System class, there is a static property called "in" that represents "standard input stream").

It is true that the clever design syntax allows the keywords to have special meanings only in specific contexts, allowing them to be used as normal identifiers. But this strategy, which complicates the syntax, has not been widely adopted.

A long history of the "For-each cycle"

The "For-each Loop" is not a control structure that appears recently. This control structure is already included in the 1979 officially released Bourne Shell (the first mature Unix command interpreter) (loops are guided by "for" and "in", and the loop body is identified with "do" and "done").

2. Prevent modification of cyclic variables in the loop body

By default, the compiler is allowed to re-assign a loop variable to the loop body of the second for loop. However, since this practice has no effect on the outside of the loop, and it is easy to create difficulties in understanding the code, it is generally not recommended.

Java provides a mechanism to block such operations during compilation. The specific method is to precede the loop variable type with a "final" modifier. In this way, the loop variable is assigned in the loop body, resulting in a compilation error. With this mechanism, it is possible to effectively eliminate intentional or unintentional "modification of cyclic variables in the loop body" operation.

Listing 7: Disallow re-assignment

int [] integers = {1, 2, 3, 4 for (finalint  i:integers) {     /*
    * / }

Note that this only disables the re-assignment of the loop variable. Assigning a value to a property of a loop variable, or invoking a method that allows the contents of a loop variable to change, is not forbidden.

Listing 8: Allow modification of State

New random[]{New New New Random (3 for (final  Random r:randoms) {     r.setseed (/* */     ** *  }

3. Type compatibility issues

To ensure that the loop variable can be safely assigned at the beginning of each cycle, J2SE 1.5 has certain limitations on the type of the loop variable. Under these restrictions, the type of the loop variable can have some choice:

The type of the loop variable can be the same as the type of the element in the object to be traversed. For example, iterate over an array of type int[by using the INT loop variable to iterate over a collection with the type of the object's loop variable.

Listing 9: Using the same type of loop variable as the element in the array to be traversed

int [] integers = {1, 2, 3, 4 for (int  i:integers) {     /** /  }

Listing 10: Using the same type of loop variable as the element in the collection to be traversed

New arraylist< string>(); Strings.add ("A") Strings.add ("B"); Strings.add ("C"); Strings.add ("D");  for /**/}

The type of the loop variable can be the ancestor type of the element in the object to be traversed. For example, iterate over an array of type byte[by using the INT loop variable to traverse a collection< string> (all elements are String collection), and so on.

Listing 11: Loop variable using the ancestor type of the element in the object to be traversed

String[] strings = {"A", "B", "C", "D"}; Collection< string> list = java.util.Arrays.asList (strings);  for (Object str:list) {System.out.println (str); /* */}

The type of the loop variable can have a relationship that can be automatically converted between the types of elements in the object to be traversed. J2SE 1.5 contains a mechanism for "autoboxing/auto-unboxing" that allows the compiler to automatically convert between basic types and their package classes (Wrapper Classes) when necessary. Therefore, it is possible to traverse an array of type int[] with an integer loop variable, or to traverse a collection< byte> with a Byte-type loop variable.

Listing 12: Looping variables for types that are automatically converted with the types of elements in the object to be traversed

int [] integers = {1, 2, 3, 4};  for /**/}

Note that the "type of element" Here is determined by the object to be traversed-if it is an array of type object[, then the element type is object, even if it contains a string object.

collection that can qualify element types

As of J2SE 1.4, there is always no way to limit the types of objects that can be saved in a Java program-they are all considered to be the most generic object objects in the collection. Until J2SE 1.5, the "Generics (generics)" mechanism was introduced, and the problem was solved. It is now possible to use collection< t> to indicate that all element types are collection of T.

Explanations of several uses of the Java for loop