简介：
两个不定类型数组交集，两个数组并集，两个数组差集
多个数组交集，多个数组并集，多个数组差集
合并多个数组：去重，不去重
数组去重
获取两个数组元素更多（少）的数组
import java.lang.reflect.Array;
import java.util.*;
/**
* Java数组常用工具类：
* 两个数组交集，两个数组并集，两个数组差集
* 多个数组交集，多个数组并集，多个数组差集
* 合并多个数组：去重，不去重
* 数组去重
* 获取两个数组元素更多（少）的数组
* -------------------
* 数组排序
*/
public class ArrUtil {
/**
* 求不定数目个数组的交集
* @param arr1
* @param arr2
* @param arrays
* @param
* @return
*/
public static T[] getInterArr(T[] arr1, T[] arr2, T[]... arrays){
T[] interArr = getInterArrTwo(arr1, arr2);
for(T[] array : arrays){
interArr = getInterArrTwo(interArr, array);
}
//set 集合转 数组 return (String[])moreSet.toArray(new String[0]);
return interArr;
}
/**
* 求两个个数组的交集
* @param arr1
* @param arr2
* @param
* @return
*/
public static T[] getInterArrTwo(T[] arr1, T[] arr2){
Set set = new HashSet(Arrays.asList(arr1));
Set interSet = new HashSet();
for(T ele : arr2){
if(set.contains(ele)){
interSet.add(ele);
}
}
T[] tArr = (T[]) Object[].class.cast(Array.newInstance(arr1[0].getClass(), interSet.size()));
//set 集合转 数组 return (String[])moreSet.toArray(new String[0]);
return interSet.toArray(tArr);
}
/**
* 求不定数目个数组的并集
* @param arr1
* @param arr2
* @param arrays
* @param
* @return
*/
public static T[] getUnionArr(T[] arr1, T[] arr2, T[]... arrays){
T[] unionArr = mergeArraysNoRepeat(arr1, arr2);
for(T[] array : arrays){
unionArr = mergeArraysNoRepeat(unionArr, array);
}
return unionArr;
}
/**
* 求多个不定类型数组的差集(就是长的)
* @param arrays 变成参数（可以传入随意个数组）--》变长参数，实际就是一个数组，所以这里应该是一个二维数组
* @param 泛型
* @return
*/
public static T[] getDifArr(T[] arr1, T[] arr2, T[]... arrays){
//先合并并去重
T[] noRepeatArr = (T[]) mergeArraysNoRepeat(arr1, arr2);
//获取差集
T[] difArr = getDifArrTwo(arr1, arr2);
//遍历二维数组，获取所有数组的差集
for(T[] arr : arrays){
//一定要先 获取去重的，和当前数组的差集以后，再将当前数组拿去去重（这样才不会漏掉）
//获取两个数组的差集
difArr = getDifArrTwo(noRepeatArr, arr);
noRepeatArr = mergeArraysNoRepeat(noRepeatArr, arr);
}
return difArr;
}
/**
* 获取两个数组的 差集
* 注意： return (T[]) difSet.toArray(new Object[]{}); 会报错，类型转换错误。因为 泛型 T 和 Object 是不能直接转换的。要想转换，需要利用反射：
* T[] o = (T[]) Object[].class.cast(Array.newInstance(m, difSet.size())); //Array.newInstance(Class class, int length) 表示知道 class，反射获取其 数组对象。class.cast(Object obj);表示将指定obj类型转换成指定class类型
* return difSet.toArray(o); //set转数组
* @param arr1
* @param arr2
* @param
* @return
*/
private static T[] getDifArrTwo(T[] arr1, T[] arr2){
//两个数组中，长度更长的数组
T[] longerArr = getLongerArr(arr1, arr2);
//两个数组中，长度更短的数组
T[] shorterArr = getShorterArr(arr1, arr2);
//差集的 set 集合，用 set 是因为 set 是不可重复的。
Set difSet = new HashSet(Arrays.asList(longerArr));
//遍历长度更短的集合
Class tClass = null;
for(T t : shorterArr){
tClass = t.getClass();
//如果差集中包含了该元素，删除掉（因为差集是 一个有，一个没有）
if(difSet.contains(t)){
difSet.remove(t);
}else {
difSet.add(t);
}
}
//Class.cast(Object obj)方法 就是作用就是强制类型转换。将obj转化成T类型。
//先使用 Array.newInstance(m, difSet.size()) 将 class 转换成数组，再使用 class 的 cast() 方法将 数组强制转换成 Object[] 类型的数组
T[] tArr = (T[]) Object[].class.cast(Array.newInstance(tClass, difSet.size()));
//set 集合转 数组 return (String[])moreSet.toArray(new String[0]);
return difSet.toArray(tArr);
}
/**
* 获取两个数组中更长的一个数组
* @param arr1
* @param arr2
* @param
* @return
*/
private static T[] getLongerArr(T[] arr1, T[] arr2){
return arr1.length >= arr2.length ? arr1 : arr2;
}
/**
* 获取两个数组中更短的一个数组
* @param arr1
* @param arr2
* @param
* @return
*/
private static T[] getShorterArr(T[] arr1, T[] arr2){
return arr1.length < arr2.length ? arr1 : arr2;
}
/**
* 合并 数组（不去重--》使用List集合来进行合并）
* List 集合 可重复的特性来实现合并不去重
* @param arr1
* @param arrays
* @param
* @return
*/
public static T[] mergeArrays(T[] arr1, T[]... arrays){
//先创建一个泛型 list 集合（因为list 是允许重复的，可变长度的）
List list = new ArrayList(Arrays.asList(arr1));
//遍历可变长度参数（可变长度参数，底层就是一个数组），这里的每一个参数都是一个数组
for(T[] array : arrays){
//遍历每一个数组，将元素添加到 list 中
for(T ele : array){
list.add(ele);
}
}
T[] tArr = (T[]) Object[].class.cast(Array.newInstance(list.get(0).getClass(), list.size()));
return list.toArray(tArr);
}
/**
* 合并 数组（去重--》使用Set集合进行合并）
* Set 集合 不可重复的特性来实现合并去重
* @param arr1
* @param arrays
* @param
* @return
*/
public static T[] mergeArraysNoRepeat(T[] arr1, T[]... arrays){
Set set = new HashSet(Arrays.asList(arr1));
for(T[] array : arrays){
for(T ele : array){
set.add(ele);
}
}
T[] arr = (T[]) Object[].class.cast(Array.newInstance(arr1[0].getClass(), set.size()));
return set.toArray(arr);
}
public static void main(String[] args){
String[] arr1 = new String[]{"A", "2", "33", "22", "55", "22"};
String[] arr2 = new String[]{"2", "3", "33", "44", "1111"};
String[] arr4 = new String[]{"2", "3", "33", "100"};
String[] arr5 = new String[]{"2", "3", "33", "101"};
// String[] arr3 = getInterArr(arr1, arr2, arr4, arr5);
// for(String i : arr3){
// System.out.println(i);
// }
TreeSet set = new TreeSet(Arrays.asList(arr1));
System.out.println(set.toString());
Arrays.sort(arr1);
}
}
需要注意的地方：
Object 和 泛型 是不能直接互相转换的，如果想要转换，需要用反射的方式来转换。如：
T[] o = (T[]) Object[].class.cast(Array.newInstance(数组类型class对象, difSet.size()));
//Array.newInstance(Class class, int length) 表示知道 class，反射获取其 数组对象。class.cast(Object obj);表示将指定obj类型转换成指定class类型
