Source implementation of Iterator in ArrayList

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

System.arraycopy source code

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.