2024-03-14  阅读(46)
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://www.skjava.com/mianshi/baodian/detail/1249589831

回答

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

  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());

阅读全文
  • 点赞