Java--List--注意问题/坑

简介

        本文介绍Java中的List的几个注意问题，包括：List#subList（获取子list）、Collections#unmodifiableList（不可修改的List）。

List#subList

        除了 ​​Arrays#asList​​ 产生新集合与原始数组互相影响之外，JDK 另一个方法 List#subList 生成新集合也会与原始 List 互相影响。

代码

package org.example.a;

import java.util.ArrayList;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(1);
        integerList.add(2);
        integerList.add(3);
        List<Integer> subList = integerList.subList(0, 2);
        subList.set(0, 10);
        integerList.set(1, 20);
        System.out.println("integerList" + integerList);
        System.out.println("subList" + subList);
    }
}

运行结果

integerList[10, 20, 3]
subList[10, 20]

原因

查看ArrayList#subList源码

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

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 内部有一个 parent字段保存保存最原始 List 。所有外部读写动作看起来是在操作SubList，实际上底层动作却都发生在原始 List 中，比如add方法：

public void add(int index, E e) {

    rangeCheckForAdd(index);

    checkForComodification();

    parent.add(parentOffset + index, e);

    this.modCount = parent.modCount;

    this.size++;

}

由于SubList实际上还在引用原始 List，业务开发中，如果不注意，很可能产生 OOM 问题。 示例：

private static List<List<Integer>> data = new ArrayList<>();

private static void oom() {
    for (int i = 0; i < 1000; i++) {
        List<Integer> rawList = IntStream.rangeClosed(1, 100000).boxed().collect(Collectors.toList());
        data.add(rawList.subList(0, 1));
    }
}

data看起来最终保存的只是 1000 个具有 1 个元素的 List，不会占用很大空间。但是程序很快就会 OOM。OOM 的原因正是因为每个 SubList 都强引用个一个 10 万个元素的原始 List，导致 GC 无法回收。

这里修复的办法也很简单，跟上面一样，，加一层 ArrayList。

解决方法

外边套一层ArrayList

package org.example.a;

import java.util.ArrayList;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(1);
        integerList.add(2);
        integerList.add(3);
        List<Integer> subList = new ArrayList<>(integerList.subList(0, 2));
        subList.set(0, 10);
        integerList.set(1, 20);
        System.out.println("integerList" + integerList);
        System.out.println("subList" + subList);
    }
}

执行结果

integerList[1, 20, 3]
subList[10, 2]

Collections#unmodifiableList

简介

        为了防止 List 集合被误操作，可用Collections#unmodifiableList生成一个不可变（immutable）集合，进行防御性编程。这个不可变集合只能被读取，不能做写操作，包括增加，删除，修改，从而保护不可变集合的安全。

        原理：返回的集合没有实现增删改的方法。

源码（不可写实例）

package org.example.a;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("one", "two", "tree"));
        List<String> unmodifiableList = Collections.unmodifiableList(list);
        // 以下三行都会抛出UnsupportedOperationException 异常
        unmodifiableList.add("four");
        unmodifiableList.remove(1);
        unmodifiableList.set(0, "test");
    }
}

执行结果

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.Collections$UnmodifiableCollection.add(Collections.java:1055)
    at org.example.a.Demo.main(Demo.java:12)

源码（原始类影响不可修改类）

package org.example.a;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("one", "two", "tree"));
        List<String> unmodifiableList = Collections.unmodifiableList(list);
        list.set(0, "one_modified");
        System.out.println(unmodifiableList.get(0));
    }
}

执行结果

one_modified

 可见，被修改了！

原因

Collections#unmodifiableList

public static <T> List<T> unmodifiableList(List<? extends T> list) {
        return (list instanceof RandomAccess ?
                new UnmodifiableRandomAccessList<>(list) :
                new UnmodifiableList<>(list));
    }

static class UnmodifiableList<E> extends UnmodifiableCollection<E>
                                  implements List<E> {
        private static final long serialVersionUID = -283967356065247728L;

        final List<? extends E> list;

        UnmodifiableList(List<? extends E> list) {
            super(list);
            this.list = list;
        }
        ...
    }

跟前边subList方法一样的情况：新集合底层实际使用（引用）了原始 List。

解决方法

法1：JDK1.9的List#of 方法

List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
List<String> unmodifiableList = List.of(list.toArray(new String[]{}));

法2：Guava包的ImmutableList

List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
List<String> unmodifiableList = ImmutableList.copyOf(list);

其他网址

​​编程坑太多，光一个List使用，就踩了5个​​