CollectionUtil

阅读更多

package com.huwei.modules.base.util;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;

public class CollectionUtil {

/**
* int数组转字符串数组
* @param as
* @return
*/
static public String[] switchArray(Integer[] as) {
if(as == null) {
return new String[] {};
}
String[] result = new String[as.length];
for(int i = 0 ,len = as.length ;i < len ;++i) {
result[i] = String.valueOf(as[i]);
}
return result;
}

/**
* 数组中包含指定元素
* @param ele 元素
* @param arrays 数组
* @return
*/
static public boolean contains(String[] arrays ,String ele) {
if(Objects.isNull(arrays) || arrays.length == 0) {
return false;
}
for(int i = 0 ,len = arrays.length ;i < len ;++i) {
if((ele == null && arrays[i] == null) || (ele != null && ele.equals(arrays[i]))) {
return true;
}
}
return false;
}

/**
* 查找集合的交集
* @param a
* @param b
* @return
*/
static public int[] intersection(int[] a ,int[] b) {
if(Objects.nonNull(a) && Objects.nonNull(b)) {
return a.length > b.length ? intersection0(b, a)
: intersection0(a, b);
}

return new int[] {};
}

static private int[] intersection0(int[] minArray ,int[] maxArray) {
int[] temp = new int[minArray.length];
int count = 0;

for(int i = 0 ,minLen = minArray.length ;i < minLen ;++i) {
int currentVal = minArray[i];
if(!contains(currentVal, temp ,0 ,count)) {
if(contains(currentVal ,maxArray ,0 ,maxArray.length)) {
temp[count++] = currentVal;
}
}
}

int[] result0 = new int[count];
System.arraycopy(temp, 0, result0, 0, count);

return result0;
}

/**
* 使用二分算法查询集合的交集
* @param a
* @param b
* @return
*/
static public int[] intersectionByBinarySearch(int[] a ,int[] b) {
if(Objects.nonNull(a) && Objects.nonNull(b)) {
return a.length > b.length ? intersectionByBinarySearch0(b, a)
: intersectionByBinarySearch0(a, b);
}

return new int[] {};
}

static private int[] intersectionByBinarySearch0(int[] minLengthArray ,int[] maxLengthArray) {
Set tempResult = new HashSet();

Arrays.sort(minLengthArray);
Arrays.sort(maxLengthArray);

for(int i = 0 ,len = minLengthArray.length ;i < len ;++i) {
int currentVale = minLengthArray[i];

if(Arrays.binarySearch(maxLengthArray, currentVale) >= 0) {
tempResult.add(Integer.valueOf(currentVale));
}
}

return setToArray(tempResult);
}

/**
* 多线程的方式，应该有调用者实现多线程
* @param a
* @param b
* @return
*/
static public int[] intersectionByMultithread(int[] a ,int[] b) {
if(Objects.nonNull(a) && Objects.nonNull(b)) {
return a.length > b.length ? intersectionByMultithread0(b, a)
: intersectionByMultithread0(a, b);
}

return new int[] {};
}

static public int[] intersectionByMultithread0(int[] minLengthArray ,int[] maxLengthArray) {
int threadNumber = Runtime.getRuntime().availableProcessors();
int maxLength = maxLengthArray.length;
int sliceArrayBaseLength = maxLength / threadNumber;

if(sliceArrayBaseLength <= 1) {return intersectionByBinarySearch0(minLengthArray, maxLengthArray);}

ConcurrentLinkedQueue