com.github.xiaoyuge5201.collections.CollectionUtils Maven / Gradle / Ivy
package com.github.xiaoyuge5201.collections;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.text.NumberFormat;
import java.util.*;
import java.util.Map.Entry;
/**
* 集合相关工具类，包括数组
*
* @author xiaoyuge
*/
public class CollectionUtils {
/**
* 以 conjunction 为分隔符将集合转换为字符串
*
* @param 被处理的集合
* @param collection 集合
* @param conjunction 分隔符
* @return 连接后的字符串
*/
public static String join(Iterable collection, String conjunction) {
StringBuilder sb = new StringBuilder();
boolean isFirst = true;
for (T item : collection) {
if (isFirst) {
isFirst = false;
} else {
sb.append(conjunction);
}
sb.append(item);
}
return sb.toString();
}
/**
* 以 conjunction 为分隔符将数组转换为字符串
*
* @param 被处理的集合
* @param array 数组
* @param conjunction 分隔符
* @return 连接后的字符串
*/
public static String join(T[] array, String conjunction) {
StringBuilder sb = new StringBuilder();
boolean isFirst = true;
for (T item : array) {
if (isFirst) {
isFirst = false;
} else {
sb.append(conjunction);
}
sb.append(item);
}
return sb.toString();
}
/**
* 将Set排序（根据Entry的值）
*
* @param set 被排序的Set
* @return 排序后的Set
*/
public static List> sortEntrySetToList(Set> set) {
List> list = new LinkedList>(set);
Collections.sort(list, new Comparator>() {
@Override
public int compare(Entry o1, Entry o2) {
if (o1.getValue() > o2.getValue()) return 1;
if (o1.getValue() < o2.getValue()) return -1;
return 0;
}
});
return list;
}
/**
* 切取部分数据
*
* @param 集合元素类型
* @param surplusAlaDatas 原数据
* @param partSize 每部分数据的长度
* @return 切取出的数据或null
*/
public static List popPart(Stack surplusAlaDatas, int partSize) {
if (surplusAlaDatas == null || surplusAlaDatas.size() <= 0) return null;
List currentAlaDatas = new ArrayList();
int size = surplusAlaDatas.size();
//切割
if (size > partSize) {
for (int i = 0; i < partSize; i++) {
currentAlaDatas.add(surplusAlaDatas.pop());
}
} else {
for (int i = 0; i < size; i++) {
currentAlaDatas.add(surplusAlaDatas.pop());
}
}
return currentAlaDatas;
}
/**
* 新建一个HashMap
*
* @return HashMap对象
*/
public static HashMap newHashMap() {
return new HashMap();
}
/**
* 新建一个HashSet
*
* @return HashSet对象
*/
public static HashSet newHashSet() {
return new HashSet();
}
/**
* 新建一个ArrayList
*
* @return ArrayList对象
*/
public static ArrayList newArrayList() {
return new ArrayList();
}
/**
* 将新元素添加到已有数组中
* 添加新元素会生成一个新的数组，不影响原数组
*
* @param buffer 已有数组
* @param newElement 新元素
* @return 新数组
*/
public static T[] append(T[] buffer, T newElement) {
T[] t = resize(buffer, buffer.length + 1, newElement.getClass());
t[buffer.length] = newElement;
return t;
}
/**
* 生成一个新的重新设置大小的数组
*
* @param buffer 原数组
* @param newSize 新的数组大小
* @param componentType 数组元素类型
* @return 调整后的新数组
*/
@SuppressWarnings({"unchecked"})
public static T[] resize(T[] buffer, int newSize, Class componentType) {
//给定类型为空时，使用原数组的类型
if (componentType == null) {
componentType = buffer.getClass().getComponentType();
}
T[] newArray = (T[]) Array.newInstance(componentType, newSize);
System.arraycopy(buffer, 0, newArray, 0, buffer.length >= newSize ? newSize : buffer.length);
return newArray;
}
/**
* 生成一个新的重新设置大小的数组
* 新数组的类型为原数组的类型
*
* @param buffer 原数组
* @param newSize 新的数组大小
* @return 调整后的新数组
*/
public static T[] resize(T[] buffer, int newSize) {
return resize(buffer, newSize, null);
}
/**
* 对list的元素按照多个属性名称排序,
* list元素的属性可以是数字（byte、short、int、long、float、double等，支持正数、负数、0）、char、String、java.util.Date
*
* @param list
* @param sortnameArr list元素的属性名称
* @param isAsc true升序，false降序
*/
public static void sort(List list, final boolean isAsc, final String... sortnameArr) {
Collections.sort(list, new Comparator() {
@Override
public int compare(E a, E b) {
int ret = 0;
try {
for (int i = 0; i < sortnameArr.length; i++) {
ret = compareObject(sortnameArr[i], isAsc, a, b);
if (0 != ret) {
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return ret;
}
});
}
/**
* 给list的每个属性都指定是升序还是降序
*
* @param list
* @param sortnameArr 参数数组
* @param typeArr 每个属性对应的升降序数组， true升序，false降序
*/
public static void sort(List list, final String[] sortnameArr, final boolean[] typeArr) {
if (sortnameArr.length != typeArr.length) {
throw new RuntimeException("属性数组元素个数和升降序数组元素个数不相等");
}
Collections.sort(list, new Comparator() {
@Override
public int compare(E a, E b) {
int ret = 0;
try {
for (int i = 0; i < sortnameArr.length; i++) {
ret = compareObject(sortnameArr[i], typeArr[i], a, b);
if (0 != ret) {
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return ret;
}
});
}
/**
* 对2个对象按照指定属性名称进行排序
*
* @param sortname 属性名称
* @param isAsc true升序，false降序
* @param a
* @param b
* @return
* @throws Exception
*/
private static int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception {
int ret;
Object value1 = forceGetFieldValue(a, sortname);
Object value2 = forceGetFieldValue(b, sortname);
String str1 = value1.toString();
String str2 = value2.toString();
if (value1 instanceof Number && value2 instanceof Number) {
int maxlen = Math.max(str1.length(), str2.length());
str1 = addZero2Str((Number) value1, maxlen);
str2 = addZero2Str((Number) value2, maxlen);
} else if (value1 instanceof Date && value2 instanceof Date) {
long time1 = ((Date) value1).getTime();
long time2 = ((Date) value2).getTime();
int maxlen = Long.toString(Math.max(time1, time2)).length();
str1 = addZero2Str(time1, maxlen);
str2 = addZero2Str(time2, maxlen);
}
if (isAsc) {
ret = str1.compareTo(str2);
} else {
ret = str2.compareTo(str1);
}
return ret;
}
/**
* 给数字对象按照指定长度在左侧补0.
*
* 使用案例: addZero2Str(11,4) 返回 "0011", addZero2Str(-18,6)返回 "-000018"
*
* @param numObj 数字对象
* @param length 指定的长度
* @return
*/
public static String addZero2Str(Number numObj, int length) {
NumberFormat nf = NumberFormat.getInstance();
// 设置是否使用分组
nf.setGroupingUsed(false);
// 设置最大整数位数
nf.setMaximumIntegerDigits(length);
// 设置最小整数位数
nf.setMinimumIntegerDigits(length);
return nf.format(numObj);
}
/**
* 获取指定对象的指定属性值（去除private,protected的限制）
*
* @param obj 属性名称所在的对象
* @param fieldName 属性名称
* @return
* @throws Exception
*/
public static Object forceGetFieldValue(Object obj, String fieldName) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
Object object = null;
boolean accessible = field.isAccessible();
if (!accessible) {
// 如果是private,protected修饰的属性，需要修改为可以访问的
field.setAccessible(true);
object = field.get(obj);
// 还原private,protected属性的访问性质
field.setAccessible(accessible);
return object;
}
object = field.get(obj);
return object;
}
}