Java｜List.subList踩坑小记

很久以前在使用 Java 的 List.subList 方法时踩过一个坑，当时记了一条待办，要写一写这事，今天完成它。

我们先来看一段代码：

// 初始化 list 为 { 1, 2, 3, 4, 5 }
List list = new ArrayList<>();
for (int i = 1; i <= 5; i++) {
    list.add(i);
}

// 取前 3 个元素作为 subList，操作 subList
List subList = list.subList(0, 3);
subList.add(6);

System.out.println(list.size());

输出是 5 还是 6？

没踩过坑的我，会回答是 5，理由是：往一个 List 里加元素，关其它 List 什么事？

而掉过坑的我，口中直呼 666。

好了不绕弯子，我们直接看下 List.subList 方法的注释文档：

/**
 * Returns a view of the portion of this list between the specified
 * fromIndex, inclusive, and toIndex, exclusive.  (If
 * fromIndex and toIndex are equal, the returned list is
 * empty.)  The returned list is backed by this list, so non-structural
 * changes in the returned list are reflected in this list, and vice-versa.
 * The returned list supports all of the optional list operations supported
 * by this list.
 *
 * This method eliminates the need for explicit range operations (of
 * the sort that commonly exist for arrays).  Any operation that expects
 * a list can be used as a range operation by passing a subList view
 * instead of a whole list.  For example, the following idiom
 * removes a range of elements from a list:
 * 
{@code
 *      list.subList(from, to).clear();
 * }
 * Similar idioms may be constructed for indexOf and
 * lastIndexOf, and all of the algorithms in the
 * Collections class can be applied to a subList.
 *
 * The semantics of the list returned by this method become undefined if
 * the backing list (i.e., this list) is structurally modified in
 * any way other than via the returned list.  (Structural modifications are
 * those that change the size of this list, or otherwise perturb it in such
 * a fashion that iterations in progress may yield incorrect results.)
 *
 * @param fromIndex low endpoint (inclusive) of the subList
 * @param toIndex high endpoint (exclusive) of the subList
 * @return a view of the specified range within this list
 * @throws IndexOutOfBoundsException for an illegal endpoint index value
 *         (fromIndex < 0 || toIndex > size ||
 *         fromIndex > toIndex)
 */
List subList(int fromIndex, int toIndex);

这里面有几个要点：

subList 返回的是原 List 的一个视图，而不是一个新的 List，所以对 subList 的操作会反映到原 List 上，反之亦然；

如果原 List 在 subList 操作期间发生了结构修改，那么 subList 的行为就是未定义的（实际表现为抛异常）。

第一点好理解，看到「视图」这个词相信大家就都能理解了。我们甚至可以结合 ArrayList 里的 SubList 子类源码进一步看下：

private class SubList extends AbstractList implements RandomAccess {
    private final AbstractList parent;
    // ...

    SubList(AbstractList parent,
            int offset, int fromIndex, int toIndex) {
        this.parent = parent;
        // ...
        this.modCount = ArrayList.this.modCount;
    }

    public E set(int index, E e) {
        // ...
        checkForComodification();
        // ...
        ArrayList.this.elementData[offset + index] = e;
        // ...
    }

    public E get(int index) {
        // ...
        checkForComodification();
        return ArrayList.this.elementData(offset + index);
    }

    public void add(int index, E e) {
        // ...
        checkForComodification();
        parent.add(parentOffset + index, e);
        this.modCount = parent.modCount;
        // ...
    }

    public E remove(int index) {
        // ...
        checkForComodification();
        E result = parent.remove(parentOffset + index);
        this.modCount = parent.modCount;
        // ...
    }

    private void checkForComodification() {
        if (ArrayList.this.modCount != this.modCount)
            throw new ConcurrentModificationException();
    }

    // ...
}

可以看到几乎所有的读写操作都是映射到 ArrayList.this、或者 parent（即原 List）上的，包括 size、add、remove、set、get、removeRange、addAll 等等。

第二点，我们在文首的示例代码里加上两句代码看现象：

list.add(0, 0);
System.out.println(subList);

System.out.println 会抛出异常 java.util.ConcurrentModificationException。

我们还可以试下，在声明 subList 后，如果对原 List 进行元素增删操作，然后再读写 subList，基本都会抛出此异常。

因为 subList 里的所有读写操作里都调用了 checkForComodification()，这个方法里检验了 subList 和 List 的 modCount 字段值是否相等，如果不相等则抛出异常。

modCount 字段定义在 AbstractList 中，记录所属 List 发生结构修改的次数。结构修改包括修改 List 大小（如 add、remove 等）、或者会使正在进行的迭代器操作出错的修改（如 sort、replaceAll 等）。

好了小结一下，这其实不算是坑，只是不应该仅凭印象和猜测，就开始使用一个方法，至少花一分钟认真读完它的官方注释文档。

网站名称：Java｜List.subList踩坑小记
本文地址：http://www.shufengxianlan.com/qtweb/news36/380036.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容