前提需要明白List是引用型別，引用型別採用引用傳遞。

　　我們經常會遇到一些需求求集合的交集、差集、並集。例如下面兩個集合:

        List<String> list1 = new ArrayList<String>();
        list1.add("A");
        list1.add("B");

        List<String> list2 = new ArrayList<String>();
        list2.add("B");
        list2.add("C");

0.求差集

　　例如，求List1中有的但是List2中沒有的元素:

    public static void test3(List list1, List list2) {
        list1.removeAll(list2);
        System.out.println(list1);
    }

結果:

[A]

檢視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);
    }

結果：

[B]

在上面2的實驗過程中，我們知道batchRemove(Collection,true)也是求交集，所以猜想retainAll 內部應該是呼叫batchRemove(Collection,true)，檢視ArrayList的原始碼如下:

    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

https://www.cnblogs.com/qlqwjy/p/9812919.html