Java List接口add方法使用与常见插入异常解决

Ja va 的 List 接口提供了三个操作元素的方法：add、addAll 和 set。日常编码中，这些方法看似简单，但用起来却有不少坑。最近在项目中踩了几个，顺手整理一下，分享给同样在写 Ja va 的朋友。

·add 方法

List 接口中的 add 方法有两种重载形式：

• ① boolean add(E e);
• ② void add(int index, E element);

方法① 是向列表末尾追加元素，也是日常使用最频繁的那个。方法② 则允许你指定插入位置——插入时，当前位置及之后的元素会自动后移。但有一个关键限制：参数 index 不能大于当前列表的 size。换句话说，如果要用这种方法填充一个空列表，必须从 0 开始，按顺序依次插入。

来看一段示例代码：

import ja va.util.ArrayList;
import ja va.util.List;
/**
 * This is the Test program.
 * @version 2018-04-06
 * @author Octopusfly
 */
 public class Main {
    public static void main(String[] args) {
        List stringList = new ArrayList<>();
        stringList.add(0, "string0");
        stringList.add(1, "string1");
        stringList.add(2, "string2");
        stringList.add(3, "string3");
        stringList.add(4, "string4");
        System.out.println(stringList);
    }
}

这段代码创建了一个 ArrayList，然后从下标 0 开始依次插入 5 个字符串，最后打印输出，运行结果如下：

现在把代码稍微改一下，调整插入顺序：

import ja va.util.ArrayList;
import ja va.util.List;
/**
 * This is the Test program.
 * @version 2018-04-06
 * @author Octopusfly
 */
 public class Main {
    public static void main(String[] args) {
        List stringList = new ArrayList<>();
        stringList.add(4, "string4");
        stringList.add(3, "string3");
        stringList.add(2, "string2");
        stringList.add(1, "string1");
        stringList.add(0, "string0");
        System.out.println(stringList);
    }
}

区别在于，这次先试图在下标 4 的位置插入元素。由于 ArrayList 初始化时 size 为 0，直接往一个不存在的下标位置插入，就会抛出 IndexOutOfBoundsException。运行结果：

注意，即使创建 List 对象时指定了初始容量（比如 new ArrayList<>(100)），也无法避免这个问题——容量只是预先分配了内存空间，size 仍然是 0，所以下标检查依然会失败。

·addAll 方法

addAll 与 add 类似，区别在于它可以一次性插入一个集合中的所有元素。同样有两种重载：

• ① boolean addAll(Collection c);
• ② boolean addAll(int index, Collection c);

带下标参数的方法②，跟 add(int index, E element) 一样，会检查 size 值，如果 index 大于 size，照样抛出异常。看下面的代码：

import ja va.util.ArrayList;
import ja va.util.HashSet;
import ja va.util.List;
import ja va.util.Set;
/**
 * This is the Test program.
 * @version 2018-04-06
 * @author Octopusfly
 */
public class Main {
    public static void main(String[] args) {
        Set stringSet = new HashSet<>();
        stringSet.add("string1");
        stringSet.add("string2");
        stringSet.add("string3");
        List stringList = new ArrayList<>();
        stringList.addAll(0, stringSet);
        System.out.println(stringList);
    }

运行结果：

如果把第 19 行改成 stringList.addAll(1, stringSet)，因为 size 为 0，index 为 1 大于 size，就会抛出异常：

此外，addAll 方法中的集合参数 c 不能传入 null，否则会抛出 NullPointerException。另外，这个方法并不是线程安全的——如果传入的集合 c 正在被另一个线程修改，最终结果是不确定的。下面这段代码可以直观地展示这一点：

import ja va.util.ArrayList;
import ja va.util.HashSet;
import ja va.util.List;
import ja va.util.Set;
/**
 * This is the Test program.
 * 
 * @version 2018-04-06
 * @author Octopusfly
 */
public class Main {
    public static void main(String[] args) {
        Set stringSet = new HashSet<>();
        List stringList = new ArrayList<>();
        Thread thread1 = new Thread() {
            public void run() {
                try {
                    for (int i = 0; i < 20; i++) {
                        stringSet.add("string" + i);
                        Thread.sleep(10);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread2 = new Thread() {
            public void run() {
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                stringList.addAll(stringSet);
                System.out.println(stringList);
            }
        };
        thread1.start();
        thread2.start();
    }
}

代码中通过 Thread.sleep 来控制线程的执行顺序，调整第 22 行和第 34 行的休眠参数，每次输出的结果都不相同——这足以说明 addAll 不是线程安全的。

·set 方法

从名字上看，set 方法像是“设置”某个位置上的元素，但本质上它执行的是替换操作。也就是说，要替换的位置上必须先有元素，否则会抛出 IndexOutOfBoundsException。来看一个典型的错误示例：

import ja va.util.ArrayList;
import ja va.util.List;
/**
 * This is the Test program.
 * 
 * @version 2018-04-06
 * @author Octopusfly
 */
public class Main {
    public static void main(String[] args) {
        List stringList = new ArrayList<>();
        stringList.set(1, "abc");
        stringList.set(2, "def");
    }
}

创建了一个空列表，然后直接在下标 1 和 2 的位置设置元素——这些位置根本没有元素，所以替换失败，抛出异常：

有些场景确实需要以乱序的方式向列表中插入元素。比如从数据库读取数据时，希望直接按序号放入 List 里，避免读取后再排序（数据量大时，内存排序开销不小）。这时候可以先把列表预填充为 null，然后再用 set 替换：

import ja va.util.ArrayList;
import ja va.util.List;
/**
 * This is the Test program.
 * 
 * @version 2018-04-06
 * @author Octopusfly
 */
public class Main {
    public static void main(String[] args) {
        List stringList = new ArrayList<>();
        stringList.add(null);
        stringList.add(null);
        stringList.add(null);
        stringList.add(null);
        stringList.add(null);
        stringList.add(null);
        stringList.set(2, "2");
        stringList.set(1, "1");
        stringList.set(0, "0");
        stringList.set(4, "4");
        stringList.set(3, "3");
        stringList.set(5, "5");
        System.out.println(stringList);
    }
}

先用 add 填充 6 个 null，然后通过 set 将对应位置替换为实际数据，这样就实现了乱序插入。运行结果如下：

总结

以上是几个关于 List 插入方法的常见陷阱和应对方式。理解这些细节，能避免不少运行时异常。实际编码中，记得根据场景选择合适的方法，并留意 size 和 index 的关系，以及线程安全的问题。