代码:
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.addAll(Arrays.asList(1, 4, 2, 5));
List<Integer> sub = list.subList(1, 3);
System.out.println("sub: " + sub);
System.out.println("list: "+list);
Collections.sort(sub);
System.out.println("sorted sub: " + sub);
System.out.println("sorted list: " + list);
}
输出:
sub: [4, 2]
list: [1, 4, 2, 5]
sorted sub: [2, 4]
sorted list: [1, 2, 4, 5]
解析:
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
在进行subList()操作时,其实返回的是ArrayList的一个子类叫做SubList的类型
private class SubList extends AbstractList<E> implements RandomAccess {
private final AbstractList<E> parent;
private final int parentOffset;
private final int offset;
int size;
SubList(AbstractList<E> parent,
int offset, int fromIndex, int toIndex) {
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount = ArrayList.this.modCount;
}
....
}
发现构造函数中包含指向原本list的引用parent。
public void add(int index, E e) {
rangeCheckForAdd(index);
checkForComodification();
parent.add(parentOffset + index, e);
this.modCount = parent.modCount;
this.size++;
}
public E remove(int index) {
rangeCheck(index);
checkForComodification();
E result = parent.remove(parentOffset + index);
this.modCount = parent.modCount;
this.size--;
return result;
}
发现此类的修改方法会对parent也进行相关的操作。
public static <T extends Comparable<? super T>> void sort(List<T> list) {
Object[] a = list.toArray();
Arrays.sort(a);
ListIterator<T> i = list.listIterator();
for (int j=0; j<a.length; j++) {
i.next();
i.set((T)a[j]);
}
}
collections.sort()方法得到其一个迭代器:
public Iterator<E> iterator() {
return listIterator();
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(offset + lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
会发现迭代器修改了原来的list