get iterator
List<LinkedHashMap> list = new ArrayList<>();
Iterator iterator = list.iterator();
iterator() method implementation
public Iterator<E> iterator() {
return new Itr();
}
Itr source code
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
Itr is an inner class of ArrayList, the structure:
remove source code
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
Check if an array is out of bounds
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
Array copy:
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
The source code of arraycopy is here
I flipped through the notes below: Knock on the key points:
- If the <code>src</code> and <code>dest</code> arguments refer to the
- same array object, then the copying is performed as if the
- components at positions <code>srcPos</code> through
- <code>srcPos+length-1</code> were first copied to a temporary
- array with <code>length</code> components and then the contents of
- the temporary array were copied into positions
- <code>destPos</code> through <code>destPos+length-1</code> of the
- destination array.
That is to say, when the original array and the array to be copied are the same, it is the movement between elements. Other implementations are not explained for the time being. Therefore, we can understand it as: delete the element at the index position of the specified array subscript, and then move forward size-index-1 elements from the position of index+1 in the table below of the array. Children's shoes who have learned data structure are well understood here. Well, not much to explain. The size here refers to the capacity of the array (if the element is not empty, it is more efficient to get the number of elements)
Other methods will be added later.