public static void test3(List list1, List list2) {
        list1.removeAll(list2);
        System.out.println(list1);
查看ArrayList的removeAll的源码
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
再查看batchRemove的源码:(如果传的第二个参数是false，保留差集;如果传的是true，保留的是交集)
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
        return modified;
　　是重新定义elementData数组的元素，下面代码的作用是将本集合中不包含另一个集合的元素重新加入元素，以此实现删除的功能(注意上面调用的方法传的参数是false，也就是不包含的元素得以保留,实现差集的功能)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
1.求并集(不去重)---将一个集合全部加入另一个集合
    public static void test(List list1, List list2) {
        list1.addAll(list2);
        System.out.println(list1);
[A, B, B, C]
查看ArayList的addAll()源码是数组复制:
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
再查看System的arraycopy发现是一个native方法(本地方法):---其实system类的好多方法都是native方法
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
2.求并集(去重)
　　例如:求List1和List2的并集,并实现去重。
　　　　思路是:先将list中与list2重复的去掉，之后将list2的元素全部添加进去。
    public static void test1(List list1, List list2) {
        list1.removeAll(list2);
        list1.addAll(list2);
        System.out.println(list1);
[A, B, C]
3.求交集
　　例如:求List1和List2中都有的元素。
    public static void test2(List list1, List list2) {
        list1.retainAll(list2);
        System.out.println(list1);
在上面2的实验过程中，我们知道batchRemove(Collection,true)也是求交集，所以猜想  retainAll 内部应该是调用 batchRemove(Collection,true)，查看ArrayList的源码如下:
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
补充：关于数组的复制和删除
　　数组的复制和删除需要通过System 工具类提供的方法来进行。
    private static void arrayTest() {
        Integer[] temps = new Integer[4];
        temps[0] = 0;
        temps[1] = 1;
        temps[2] = 2;
        System.out.println(Arrays.toString(temps));
        // 相当于扩容, 扩容1.5 倍。这里注意优先级， + 优先于大于位移，所以需要加括号。 底层实际调用的也是System.arraycopy
        Integer[] ints = Arrays.copyOf(temps, temps.length + (temps.length >> 1));
        System.out.println(Arrays.toString(ints));
        // 手动扩容至两倍
        Integer[] integers = (Integer[]) Array.newInstance(ints.getClass().getComponentType(), temps.length + temps.length);
        System.out.println(Arrays.toString(integers));
        integers[0] = -1;
         * temps: src 数组
         * 1: src 数组起始下标
         * destPos: dest数组
         * 1: dest数组起始位置
         * 2: 从src数组复制几个元素
        System.arraycopy(temps, 1, integers, 1, 2);
        System.out.println(Arrays.toString(integers));
[0, 1, 2, null]
[0, 1, 2, null, null, null]
[null, null, null, null, null, null, null, null]
[-1, 1, 2, null, null, null, null, null]