Comparative analysis of For and For-each applications in Java loops

for-each implementation method

For-each is not a new syntax, but syntax sugar for Java. At compile time, the compiler converts this code into an iterator implementation and compiles it into bytecode. We can decompile the following compiled code by executing the commandjavap-verbose-Testforeach:

public class TestForeach { List integers; public void testForeach(){ for(Integer i : integers){ } } }

The detailed bytecode obtained is as follows:

public void testForeach(); descriptor: ()V flags: ACC_PUBLIC Code: stack=1, locals=3, args_size=1 0: aload_0 1: getfield #2 // Field integers:Ljava/util/List; 4: invokeinterface #3, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator; 9: astore_1 10: aload_1 11: invokeinterface #4, 1 // InterfaceMethod java/util/Iterator.hasNext:()Z 16: ifeq 32 19: aload_1 20: invokeinterface #5, 1 // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object; 25: checkcast #6 // class java/lang/Integer 28: astore_2 29: goto 10 32: return LineNumberTable: line 11: 0 line 13: 29 line 14: 32 LocalVariableTable: Start Length Slot Name Signature 29 0 2 i Ljava/lang/Integer; 0 33 0 this Ltest/TestForeach; }

General of this bytecode The meaning is to use thegetfileldcommand to get theintegersvariable and callList.iteratorto get the iterator instance and calliterator.hasNext. Iftrueis returned, call theiterator.nextmethod.

Please see, this is the implementation logic of iterator traversing the collection.

Benchmarking

Now let us test using for loop method and for-each method.

public class ForLoopTest { public static void main(String[] args) { List arrayList = new ArrayList<>(); for (int i = 0; i < 10000000; i++) { arrayList.add(i); } long arrayListStartTime = System.currentTimeMillis(); for (int i = 0; i < arrayList.size(); i++) { arrayList.get(i); } long arrayListCost =System.currentTimeMillis()-arrayListStartTime; System.out.println("ArrayList for loop traversal cost: "+ arrayListCost); long arrayListForeachStartTime = System.currentTimeMillis(); for (Integer integer : arrayList) { } long arrayListForeachCost =System.currentTimeMillis()-arrayListForeachStartTime; System.out.println("ArrayList foreach traversal cost: "+ arrayListForeachCost);

Here are the test results:

As you can see, the results are obvious. Using the For loop method is more efficient on ArrayList than the For each method.

Can we say that for loop is better than for-each?

the answer is negative. In the next benchmark, we change the ArrayList to a LinkedList.
Again, here are the test results.

Cause Analysis

Some beginners may wonder why ArrayList uses the for loop method to traverse faster, while LinkedList is slower and very slow ?

This is determined by the ArrayList and LinkedList data structures.
The bottom layer of ArrayList uses arrays to store elements. Arrays are contiguous memory spaces. Data can be obtained through indexes. The time complexity is O(1), so it's fast.

The bottom layer of LinkedList is a doubly linked list. Use a for loop to implement traversal, starting from the head node of the linked list each time. The time complexity is O(n*n).

Conclusion

• When using ArrayList, the for loop method is faster because for-each is implemented by iterators and needs to perform concurrent modification verification.

• When using LinkedList, for-each is much faster than for loop because LinkedList is implemented by using a doubly linked list. Every addressing needs to start from the head node. When iterating over a LinkedList, avoid using for loops.

• Using the iterator pattern, for-each does not need to care about the specific implementation of the collection. If a collection needs to be replaced, it can be easily done without modifying the code.

The above is the detailed content of Comparative analysis of For and For-each applications in Java loops. For more information, please follow other related articles on the PHP Chinese website!