问题一：注意不可变的集合

• 使用JDK提供的Collections类构造出来的list，需要注意大多数情况下都是不可变的
• Arrays.asList构造出来的也是不可变的
• 使用一些其他第三方工具类时，也需要注意，例如guava中的ImmutableList构建的都是不可变的集合。

// EMPTY_LIST
List<String> emptyList = Collections.EMPTY_LIST;
emptyList.add("a");

// singletonList
List<String> singletonList = Collections.singletonList("a");
singletonList.add("b");

// unmodifiableList
List<Object> unmodifiableList = Collections.unmodifiableList(new ArrayList<>());
unmodifiableList.add("a");

// asList
List<String> asList = Arrays.asList("a");
asList.add("b");

// ImmutableList
ImmutableList<String> immutableList = ImmutableList.of("a");
immutableList.add("b");

问题二：subList

List提供的subList方法，返回的是原list的一个视图，其引用指向的是同一个，所以使用时需要特别注意。

1.修改了subList，原list也会受到影响

ArrayList<String> list = new ArrayList<>();
list.add("a");
List<String> subList = list.subList(0, 1);
System.out.println("变化前：" + subList);
System.out.println("变化前：" + list);
subList.add("b");
// 虽然只修改了subList，但原list同样会有影响
System.out.println("变化后：" + subList);
System.out.println("变化后：" + list);

2.ConcurrentModificationException异常

ArrayList<String> list = new ArrayList<>();
list.add("a");
List<String> subList = list.subList(0, 1);
list.add("b");
// 原list一旦变更过，subList遍历、增加、删除都会产生ConcurrentModificationException
System.out.println(subList);

3.内存溢出

看起来每次只往subList中添加一个元素，但实际上是整个list，导致最终内存被大量使用，甚至最后抛出OOM

List<List<Integer>> subList= new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    List<Integer> list = new ArrayList<>();
    for (int j = 0; j < 100000; j++) {
        list.add(j);
    }
    subList.add(list.subList(0, 1));
}

问题三：toArray类型转换

如果使用无参的toArray方法，则不能进行强制转换，否则会报ClassCastException异常

List<String> list = new ArrayList<>();
list.add("a");
String[] strings = (String[]) list.toArray();

无参的只能是Object类型，改成下面就没有问题

List<String> list = new ArrayList<>();
list.add("a");
Object[] objects = list.toArray();

或者使用有参的构造方法也可以

List<String> list = new ArrayList<>();
list.add("a");
String[] objects = list.toArray(new String[]{});

问题四：asList转换

Arrays.asList方法如果传入的是基础类型，则会直接当做一个整体

int[] arr = {1, 2, 3};
List list = Arrays.asList(arr);
System.out.println(Arrays.toString((int[]) list.get(0))); // 输出结果：[1, 2, 3]

如果传入的是引用类型，则会按照数组元素进行转换

Integer[] arr = {1, 2, 3};
List list = Arrays.asList(arr);
System.out.println(list.get(0)); // 输出结果：1

问题五：在遍历时进行修改

运行后，会抛出ConcurrentModificationException异常，如果把b换成a却没有问题。

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
for (String str : list) {
    if("b".equals(str)){
        list.remove(str);
    }
}

可以通过迭代器的方式来实现

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
    String next = iterator.next();
    if("b".equals(next)){
        iterator.remove();
    }
}

JDK11直接提供了removeIf方法，实际上其内部还是使用的iterator的方式

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.removeIf("b"::equals);

removeIf实现逻辑

default boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    boolean removed = false;
    final Iterator<E> each = iterator();
    while (each.hasNext()) {
        if (filter.test(each.next())) {
            each.remove();
            removed = true;
        }
    }
    return removed;
}