回答

因为 ArrayList 的 subList() 返回的是原始列表的一个子列表视图，这个特性带来了一些便利，但带来的坑就更加多了：

1. 互相影响：任何对原始列表或者子列表进行的非结构性改变都会互相影响。
2. 反向影响：任何对子列表的结构修改都会影响到原始列表。
3. 结构性修改的限制：如果原始列表进行了结构性的修改（添加、删除元素），那么子列表将变得不可用，使用子元素会抛出 ConcurrentModificationException 异常。
4. 内存泄漏：子列表持有对原始列表的引用，这意味着即使原始列表的其他部分不再需要，只要子列表还在使用，原始列表就不能被垃圾回收。在某些情况下，这可能导致意外的内存泄漏，尤其是在原始列表很大，而子列表只是很小一部分时。

详解

互相影响

任何对原始列表或者子列表进行的非结构性改变都会互相影响。

    @Test
    public void subListTest() {
        List<String> list = new ArrayList<>();
        list.add("skjava");
        list.add("sike");
        list.add("sike-java");
        list.add("sike-netty");
        list.add("sike-redis");
        list.add("sike-spring");
        list.add("sike-nio");

        List<String> subList = list.subList(1,4);

        // 修改子列表
        subList.set(2,"sike-netty-01");
        System.out.println("原始列表：" + list);
        System.out.println("子列表：" + subList);
        System.out.println("=======================");
        // 修改原始列表
        list.set(1,"sike-01");
        System.out.println("原始列表：" + list);
        System.out.println("子列表：" + subList);
    }

结果：

从结果中可以看出，修改子列表影响原始列表，修改原始列表影响子列表。

反向影响

任何对子列表的结构修改都会影响到原始列表。

    @Test
    public void subListTest() {
        //...
        
        // 子列表增加一个数据
        subList.add("sike-spring ioc");
        System.out.println("原始列表：" + list);
        System.out.println("子列表：" + subList);
    }

结果

子列表增加一个元素 sike-spring ioc，原始列表也会在“相同”的位置增加一个 sike-spring ioc。

结构性修改的限制

如果原始列表进行了结构性的修改（添加、删除元素），那么子列表将变得不可用，使用子元素会抛出 ConcurrentModificationException 异常。

    @Test
    public void subListTest() {
        //...

        // 子列表增加一个数据
        list.add(3,"sike-interview");
        System.out.println("原始列表：" + list);
        System.out.println("子列表：" + subList);
    }

结果：

原始列表增加一个元素，它可以正常使用，但是在使用子列表的时候抛出了 ConcurrentModificationException 异常。

源码分析

为什么会出现这种情况呢？我们直接看源码：

    public List<E> subList(int fromIndex, int toIndex) {
        // 索引校验
        subListRangeCheck(fromIndex, toIndex, size);
        // 构造一个 SubList 对象
        return new SubList(this, 0, fromIndex, toIndex);
    }

这里是直接构造一个 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;
        }
        
        //....
      }

SubList 是 ArrayList 的一个内部类，它是原始 ArrayList 的一个视图，从 fromIndex（包含）到 toIndex（不包含）。而且从构造函数上面看 SubList 并没有新建一个数组或者 List 对象，而是直接引用了原始的 List，只是指定了一下他要使用的元素的范围而已。所以两者同体。

那为什么结构性修改子列表时，使用原始列表时，不会报错，而结构性修改原始列表时，使用子列表时会抛出 ConcurrentModificationException 异常呢？

查看相关源码，你会发现 SubList 的所有方法都会调用 checkForComodification() 进行 modCount 校验。而调用 SubList 的结构性修改方法时它最终都会去调用原始列表的对应方法，同时赋值 modCount，以 add() 为例：

        public void add(int index, E e) {
            rangeCheckForAdd(index);
            checkForComodification();
            // 调用原始队列的 add()
            parent.add(parentOffset + index, e);
            // 复制 modCount
            this.modCount = parent.modCount;
            this.size++;
        }

解决方式

• 在 subList() 返回 SubList，重新使用 new ArrayList，来构建一个独立的 ArrayList:

List list = new ArrayList<>(collect.subList(0, 1));

• 利用 Java8 的 Stream 中的 skip 和 limit 来达到切片的目的

List list = collect.stream().skip(0).limit(1).collect(Collectors.toList());