为什么API在ArrayList的子列表的列表迭代器的next（）中引发并发修改异常？

Question

This is in reference to the first level sub list of an arraylist.

We have this source code-

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;   // initially cursor is set to 0
            if (i >= SubList.this.size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (offset + i >= elementData.length)
                throw new ConcurrentModificationException();  // WHY? 
            cursor = i + 1;
            return (E) elementData[offset + (lastRet = i)];
        }

Why throw a ConcurrentModificationException instead of IndexOutOfBoundsException ?

Why concurrent?

---

NOTE:-

I am still struggling with the design part.

This is in reference to the comment by @Kayaman

Consider the below arraylist and its sublist-

el      original    sublist
0       a[0]
10      a[1]
20      a[2]        s[0]
30      a[3]        s[1]
40      a[4]        s[2]
50      a[5]        s[3]
60      a[6]        s[4]
70      a[7]
80      a[8]
90      a[9]

Every sublist has 2 instance variables

parent offset - diff b/w the first index location of parent and sub list.

offset - diff b/w the first index location of original and sub list.

There is internally an array elementData which backs this arraylist Even if some thread removes an element from the original arraylist (concurrent modification), the size gets reduced by 1 , but the length of elementData remains the same.

fast remove internally c/d by remove(Object) -

private void fastRemove(int index) {
    modCount++;
    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
}

I see that this condition will never be fulfilled- offset + i >= elementData.length even after removal concurrently.

Any suggestions?

Answer 1

Because on creation of the Sublist , a range check is performed:

public List<E> subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, offset, fromIndex, toIndex);
}

So the Sublist will never go beyond the end of the source list.

Therefore, offset + i will always be inside the valid range of the original List except it has been modified in the meantime.

Note that Sublist takes any AbstractList<> as its source List ; so even if ArrayList itself does not shrink its backing array on a remove, a subclass might do so - which would cause Sublist to be incorrect here.