java用最少循環求兩個數組的交集、差集、並集

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 用最少循環求兩個數組的交集、差集、並集
 * 
 * @author ZQC
 *
 */
public class Test
{

    public static void main(String[] args)
    {
        Integer[] m = { 1, 2, 3, 4, 5 };
        Integer[] n = { 3, 4, 6 };

        System.out.println("----------並集------------");
        Integer[] b = getB(m, n);
        for (Integer i : b)
        {
            System.out.println(i);
        }

        System.out.println("----------交集------------");
        Integer[] j = getJ(m, n);
        for (Integer i : j)
        {
            System.out.println(i);
        }

        System.out.println("----------差集------------");
        Integer[] c = getC(m, n);
        for (Integer i : c)
        {
            System.out.println(i);
        }
    }

    /**
     * 求並集
     * 
     * @param m
     * @param n
     * @return
     */
    private static Integer[] getB(Integer[] m, Integer[] n)
    {
        // 將數組轉換爲set集合
        Set<Integer> set1 = new HashSet<Integer>(Arrays.asList(m));
        Set<Integer> set2 = new HashSet<Integer>(Arrays.asList(n));

        // 合併兩個集合
        set1.addAll(set2);

        Integer[] arr = {};
        return set1.toArray(arr);
    }

    /**
     * 求交集
     * 
     * @param m
     * @param n
     * @return
     */
    private static Integer[] getJ(Integer[] m, Integer[] n)
    {
        List<Integer> rs = new ArrayList<Integer>();

        // 將較長的數組轉換爲set
        Set<Integer> set = new HashSet<Integer>(Arrays.asList(m.length > n.length ? m : n));

        // 遍歷較短的數組，實現最少循環
        for (Integer i : m.length > n.length ? n : m)
        {
            if (set.contains(i))
            {
                rs.add(i);
            }
        }

        Integer[] arr = {};
        return rs.toArray(arr);
    }

    /**
     * 求差集
     * 
     * @param m
     * @param n
     * @return
     */
    private static Integer[] getC(Integer[] m, Integer[] n)
    {
        // 將較長的數組轉換爲set
        Set<Integer> set = new HashSet<Integer>(Arrays.asList(m.length > n.length ? m : n));

        // 遍歷較短的數組，實現最少循環
        for (Integer i : m.length > n.length ? n : m)
        {
            // 若是集合裏有相同的就刪掉，若是沒有就將值添加到集合
            if (set.contains(i))
            {
                set.remove(i);
            } else
            {
                set.add(i);
            }
        }

        Integer[] arr = {};
        return set.toArray(arr);
    }

}