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>
ab00
目标数组对象类型
* @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;
}

}