【Java常见错误案例】List集合的操作

前言

List集合应该是我们平时工作中使用非常频繁的一种数据结构，有非常多的关于其操作的API，正因如此，我们也遇到了各种各样问题，本文针对一些常见的问题做了总结，一起来看一下吧。

一、问题案例

1. 注意不可变的集合

• 使用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");

2. subList

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

2.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.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);

2.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));
}

3. 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[]{});

4. 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

5. 在遍历时进行修改

运行后，会抛出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;
}

6. remove操作

下面两段代码，仅仅因为一个使用的是int，另一个使用的是int的包装类，就产生了不一样的结果

ArrayList<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5);
int idx = 1;
list.remove(idx);
System.out.println(list); // 结果：[1, 3, 4, 5]

ArrayList<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5);
Integer idx = 1;
list.remove(idx);
System.out.println(list); //结果：[2, 3, 4, 5]

实际上只是因为list.remove方法提供了两种不同类型入参的方法，如果是int类型，则入参作为索引下标，按照索引下标进行删除，如果是Integer类型，则入参的值就作为要删除的元素。

public E remove(int index) {
    rangeCheck(index);
    modCount++;
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
}

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}