java数组的交集、并集、差集

编程题目: 
1. 验证集合中是否包含目标元素
public static <T> boolean contains(T[] array, T target)


2. 验证集合A是否不含集合B中的任意元素
public static <T> boolean containsNon(T[] a, T[] b)


3. 验证集合A是否包含集合B中的至少一个元素
public static <T> boolean containsAny(T[] a, T[] b)


4. 验证集合A是否包含集合B中的所有元素

public static <T> boolean containsAll(T[] a, T[] b)

public class Test20170504 {

	public static void main(String[] args) {
		// 1. 验证集合中是否包含目标元素
		String[] a1 = null;
		String[] a2 = new String[]{};
		String[] a3 = new String[]{ null, "", "abc" };
		String   t1 = null;
		String   t2 = "";
		String   t3 = "abc";
		String   t4 = "def";
		System.out.println("==============================================");
		System.out.println("1. 验证集合中是否包含目标元素");
		System.out.println("==============================================");
		System.out.println("> 数据展示");
		System.out.println("a1 = " + print(a1));
		System.out.println("a2 = " + print(a2));
		System.out.println("a3 = " + print(a3));
		System.out.println("t1 = null");
		System.out.println("t2 = \"\"");
		System.out.println("t3 = \"abc\"");
		System.out.println("t4 = \"def\"");
		System.out.println("> 验证");
		System.out.println("contains(a1, t1) : " + contains(a1, t1));
		System.out.println("contains(a1, t2) : " + contains(a1, t2));
		System.out.println("contains(a1, t3) : " + contains(a1, t3));
		System.out.println("contains(a2, t1) : " + contains(a2, t1));
		System.out.println("contains(a2, t2) : " + contains(a2, t2));
		System.out.println("contains(a2, t3) : " + contains(a2, t3));
		System.out.println("contains(a3, t1) : " + contains(a3, t1));
		System.out.println("contains(a3, t2) : " + contains(a3, t2));
		System.out.println("contains(a3, t3) : " + contains(a3, t3));
		System.out.println("contains(a3, t4) : " + contains(a3, t4));
		
		// 2. 集合之间的比较: 不含, 包含至少一项, 包含全部
		String[] _a1 = null;
		String[] _a2 = new String[]{};
		String[] _a3 = new String[]{ "ab", "cd", "ef" };
		String[] _a4 = new String[]{ "cd", "ef", "gh" };
		String[] _a5 = new String[]{ "gh", "ij", "kl" };
		String[] _a6 = new String[]{ "ab", "cd" };
		String[] _a7 = new String[]{ "ab", "cd", "ef", "gh" };
		System.out.println("\n==============================================");
		System.out.println("2. 集合之间的比较: 不含, 包含至少一项, 包含全部");
		System.out.println("==============================================");
		System.out.println("> 数据展示");
		System.out.println("a1 = " + print(_a1));
		System.out.println("a2 = " + print(_a2));
		System.out.println("a3 = " + print(_a3));
		System.out.println("a4 = " + print(_a4));
		System.out.println("a5 = " + print(_a5));
		System.out.println("a6 = " + print(_a6));
		System.out.println("a7 = " + print(_a7));
		System.out.println("> 验证");
		System.out.println("containsNon(a1, a2) : " + containsNon(_a1, _a2));
		System.out.println("containsNon(a3, a1) : " + containsNon(_a3, _a1));
		System.out.println("containsNon(a3, a2) : " + containsNon(_a3, _a2));
		System.out.println("containsNon(a3, a4) : " + containsNon(_a3, _a4));
		System.out.println("containsNon(a3, a5) : " + containsNon(_a3, _a5));
		System.out.println("containsNon(a3, a6) : " + containsNon(_a3, _a6));
		System.out.println("containsNon(a3, a7) : " + containsNon(_a3, _a7));
		System.out.println("containsAny(a1, a2) : " + containsAny(_a1, _a2));
		System.out.println("containsAny(a3, a1) : " + containsAny(_a3, _a1));
		System.out.println("containsAny(a3, a2) : " + containsAny(_a3, _a2));
		System.out.println("containsAny(a3, a4) : " + containsAny(_a3, _a4));
		System.out.println("containsAny(a3, a5) : " + containsAny(_a3, _a5));
		System.out.println("containsAny(a3, a6) : " + containsAny(_a3, _a6));
		System.out.println("containsAny(a3, a7) : " + containsAny(_a3, _a7));
		System.out.println("containsAll(a1, a2) : " + containsAll(_a1, _a2));
		System.out.println("containsAll(a3, a1) : " + containsAll(_a3, _a1));
		System.out.println("containsAll(a3, a2) : " + containsAll(_a3, _a2));
		System.out.println("containsAll(a3, a4) : " + containsAll(_a3, _a4));
		System.out.println("containsAll(a3, a5) : " + containsAll(_a3, _a5));
		System.out.println("containsAll(a3, a6) : " + containsAll(_a3, _a6));
		System.out.println("containsAll(a3, a7) : " + containsAll(_a3, _a7));
	}
	
	
	// 辅助方法
	/**
	 * 验证一个对象数组是否为空或不含任何元素
	 * 
	 * @param <T>   目标数组对象类型
	 * @param array 目标数组
	 * @return 数组为空或不含任何元素, 返回{@code true}; 否则, 返回{@code false}
	 */
	private static <T> boolean isEmpty(T[] array) {
		return array == null || array.length == 0;
	}
	
	/**
	 * 显示数组信息
	 * 
	 * @param <T>   数组对象类型
	 * @param array 目标数组
	 * @return 数组信息
	 */
	private static <T> String  print(T[] array) {
		if (array == null) {
			return "null";
		}
		
		if (array.length == 0) {
			return "{}";
		}
		
		StringBuffer buffer = new StringBuffer(128);
		buffer.append("{");
		for (T item : array) {
			buffer.append(item == null ? "null" : ("\"" + item.toString() + "\"")).append(", ");
		}
		buffer.append("}");
		return buffer.toString().replace(", }", "}");
	}
	
	
	// 1. 验证集合中是否包含目标元素
	/**
	 * 验证一个集合数组中是否包含目标对象
	 * 
	 * @param array  目标数组
	 * @param target 目标对象
	 * @return 数组不为空且至少包含一个元素, 且包含目标对象时, 返回{@code true}; 否则, 返回{@code false}
	 */
	public static <T> boolean contains(T[] array, T target) {
		if (!isEmpty(array)) {
			if (target == null) {
				for (T item : array) {
					if (item == null) {
						return true;
					}
				}
			} else {
				for (T item : array) {
					if (target.equals(item)) {
						return true;
					}
				}
			}
		}
		return false;
	}
	
	
	// 2. 验证集合A是否不含集合B中的任意元素
	/**
	 * 验证集合A是否不含集合B中的任意元素
	 * 
	 * @param a 集合A
	 * @param b 集合B
	 * @return 集合A或集合B为空或不含任何元素, 或集合A不含集合B中的任意元素, 返回{@code true}; 否则, 返回{@code false}
	 */
	public static <T> boolean containsNon(T[] a, T[] b) {
		// 集合A或集合B为空或不含任何元素
		if (isEmpty(a) || isEmpty(b)) {
			return true;
		}
		
		// 集合A或集合B不为空且至少包含一个元素
		for (T item : b) {
			if (contains(a, item)) {
				return false;
			}
		}
		return true;
	}
	
	
	// 3. 验证集合A是否包含集合B中的至少一个元素
	/**
	 * 验证集合A是否包含集合B中的至少一个元素
	 * 
	 * @param a 集合A
	 * @param b 集合B
	 * @return 集合A和集合B不为空且至少包含一个元素, 且集合A包含集合B中的至少一个元素, 返回{@code true}; 否则, 返回{@code false}
	 */
	public static <T> boolean containsAny(T[] a, T[] b) {
		// 集合A或集合B为空或不含任何元素
		if (isEmpty(a) || isEmpty(b)) {
			return false;
		}
		
		// 集合A或集合B不为空且至少包含一个元素
		for (T item : b) {
			if (contains(a, item)) {
				return true;
			}
		}
		return false;
	}
	
	
	// 4. 验证集合A是否包含集合B中的所有元素
	/**
	 * 验证集合A是否包含集合B中的所有元素
	 * 
	 * @param a 集合A
	 * @param b 集合B
	 * @return 集合A和集合B不为空且至少包含一个元素(集合A中包含的元素个数不少于集合B), 且集合A包含集合B中所有元素, 返回{@code true}; 否则, 返回{@code false}
	 */
	public static <T> boolean containsAll(T[] a, T[] b) {
		// 集合A或集合B为空或不含任何元素, 或集合A中包含的元素个数少于集合B
		if (isEmpty(a) || isEmpty(b) || a.length < b.length) {
			return false;
		}
		
		// 集合A或集合B不为空且至少包含一个元素, 且集合A中包含的元素个数不少于集合B
		for (T item : b) {
			if (!contains(a, item)) {
				return false;
			}
		}
		return true;
	}

}