What is the difference between using foreach and iterator to delete elements when traversing Java ArrayList?

1. The difference between Iterator and foreach

• Polymorphic difference (the bottom layer of foreach is Iterator)

• Iterator is an interface type, it does not care about the type of the collection or array;

• Both for and foreach need to know the type of the collection first, even the type of the elements in the collection ;

1. Why is it said that the bottom layer of foreach is the code written by Iterator

:

##Decompiled code:

2. The difference between remove during foreach and iterator

Let’s look at Ali first Java Development Manual

But no error will be reported in time 1, and an error will be reported in time 2 (java.util.ConcurrentModificationException)

First come Take a look at the implementation of the iterator method in ArrayList:

calls new Itr() to generate the Itr class (iterator). At this time, the three parameters of Itr will be initialized.

cursor represents the next index position (starting at 0)
size is the size of the collection (2)

Throw exception class

When next method (), checkForComodification will be checked for equality

modCount modification count (each add and remove will be 1) expectedModCount expected maximum count

1.remove operation source code analysis

First let’s take a look at deleting “2” Situation:

First loop:
Because the modCount and expectedModCount at this time are both 2 (modCount is 2 because it was added twice), so no exception will be thrown in the first loop , exceptions are thrown when it is not the first time in the loop. After the next method is completed, the if condition of the remove method in the foreach loop method body is not satisfied, and the loop ends.
Second loop:
The hasNext and next methods of the second loop can be completed successfully. After that, it will enter the remove method in the foreach loop method body. To delete elements. At this time, size-1 becomes 1. In the fastRemove method in the remove method, modCount is set to 1, which becomes 3.

The third loop:

Then it will go to the hasNext method in the third loop. Under normal circumstances, this method will return false, but because the size at this time has changed to 1, and the cursor at this time is 2 (cursor represents the next index position), so the two are not equal, and an error is returned. true, so it will continue to go to the checkForComodification method in the next method to determine whether the modCount and expectedModCount at this time are equal. Because the modCount at this time has changed to 3, which is different from the expectedModCount value of 2, a ConcurrentModificationException exception was thrown here.

Let’s take a look at why no exception is thrown when deleting “1”:

First loop:

Same as above, the modCount and expectedModCount at this time are both 2, so the hasNext and next methods in the first loop will not throw an exception. After this, you will enter the remove method in the foreach loop method body to delete the element. Same as above, size-1 becomes 1, and modCount 1 becomes 3.

The second loop:

In the hasNext method of the second loop, the cursor at this time is 1, and the size is also 1, and they are equal. Therefore, when the hasNext method returns false, it will jump out of the foreach loop and will not go to the subsequent next method, so it will not throw an exception.

2. Source code steps

The first time

The first sentence calls iterator(),

Call new Itr() to generate the Itr class (iterator). At this time, the three parameters of Itr will be initialized.

At this time expectedModCount == modCount == 2 (because the list mobilizes the add method, the add method will implement the operation on modCount)
The second sentence calls the hasNext() method below to return the subscript of the next element to be accessed. cursor, because it is the first loop, so the cursor is 0 and the size is 2 (0 != 2 true)
The next() method is called in the third sentence, and the if condition of the remove method in the foreach loop method body is not satisfied. , this ends the cycle

The second time

The second sentence calls the hasNext() method below and returns the subscript cursor of the next element to be accessed. Second loop, so the cursor is 1,
size is still 2 (1 != 2 true)
The third sentence calls the next() method, takes the value normally, and gets the first element "2";
Sentence ④ calls the remove() method and successfully deletes elements from the list. Note that when calling the remove method, there is modCount. All at this time, modCount3, expectedModCount2, size1

The third time

The second sentence calls the hasNext() method below and returns the subscript cursor of the next element to be accessed. , the second loop, so the cursor is 2 and the size is 1
The third sentence calls the next() method. Note that the first sentence in the next() method is to call checkForComodification(); due to modCount(3)! = expectedModCount(2), so an exception was thrown.

3. Why is iterator the bottom layer, why does foreach report an error

When the loop ends, while (iterator.hasNext() ) will check whether the next element exists. After remove delete 2 is completed, the next time you enter the cursor is still 1, and the size is also 1.
Foreach, after removing remove2, the next time you enter the cursor is 2, and the size is 1, so To return false, go to the next method, and then check, modCount=3, and expectedModCount=2

3. View the source code method

If you view the ArrayList under iterator

The above is the detailed content of What is the difference between using foreach and iterator to delete elements when traversing Java ArrayList?. For more information, please follow other related articles on the PHP Chinese website!