其他網址
數組轉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);