其他网址
数组转List
Arrays$ArrayList：不支持增删操作；共享原始数据（Arrays$ArrayList元素与Arrays的数组元素是共享的）。
源码（增加）
package org.example.a;
import java.util.Arrays;
import java.util.List;
public class Demo {
public static void main(String[] args) {
String[] strings = {"1", "2", "3"};
List<String> list = Arrays.asList(strings);
list.add("abc");
System.out.println(list);
}
}
运行结果
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at org.example.a.Demo.main(Demo.java:10)
分析
Arrays#asList 返回的 ArrayList 只是 Arrays 一个内部类，并非真正的 java.util.ArrayList。
java.util.ArrayList和Arrays$ArrayList都继承自 AbstractList。而 java.util.Arrays$ArrayList 并没有重写父类的add/remove方法。而父类方法恰恰都会抛出 UnsupportedOperationException。
源码（修改）
package org.example.a;
import java.util.Arrays;
import java.util.List;
public class Demo {
public static void main(String[] args) {
String[] strings = {"1", "2", "3"};
List<String> list = Arrays.asList(strings);
list.set(0, "modify_1");
strings[1] = "modify_2";
System.out.println(list);
}
}
执行结果
[modify_1, modify_2, 3]
原因
查看 java.util.Arrays$ArrayList 实现，我们可以发现底层实际使用了原始数组。
解决方法
法1：外边套一层ArrayList
List<String> list = new ArrayList<>(Arrays.asList(arrays));
法2：使用谷歌的Guava包的Lists.newArrayList
List<String> list = Lists.newArrayList(arrays);
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);