com.base4j.util.CollectionsUtil Maven / Gradle / Ivy
package com.base4j.util;
import com.base4j.util.bean.ChangeResult;
import com.base4j.util.bean.Constant;
import com.base4j.util.exceptions.ValidateException;
import com.base4j.util.lang.Conver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
/**
* 集合处理工具
*
* @author HuangJun
* @version 1.0
* @date 2017年3月30日
*/
public class CollectionsUtil {
public static Logger logger = LoggerFactory.getLogger(CollectionsUtil.class);
private final static String SPLIT_STR = ",";
private final static String SPLIT_STR_SPECIAL = "■";
private CollectionsUtil() {
// 静态类不可实例化
}
/**
* List转Map，返回Map默认以“,”分隔
*
* @param list 待处理集合
* @param pk 主键
* @return
*/
public final static Map list2Map(List list, String pk) {
return list2Map(list, pk, String.class);
}
/**
* List转Map，返回Map默认以“,”分隔
*
* @param list 待处理集合
* @param pk 主键
* @param t 返回类型，返回Map默认以，分隔
* @param 返回数据类型
* @param 集合数据类型
* @return
*/
public final static Map list2Map(List list, String pk, Class t) {
return list2Map(list, new String[]{pk}, t, null);
}
/**
* List转Map，返回Map默认以“,”分隔
*
* @param list 待处理集合
* @param pkArr 主键数组
* @param t 返回类型，返回Map默认以，分隔
* @param 返回数据类型
* @param 集合数据类型
* @return
*/
public final static Map list2Map(List list, String[] pkArr, Class t) {
return list2Map(list, pkArr, t, null);
}
/**
* List转Map
*
* @param list 待处理集合
* @param pkArr 主键数组
* @param t 返回类型
* @param t Map键分隔符号
* @param 返回数据类型
* @param 集合数据类型
* @return
*/
public final static Map list2Map(List list, String[] pkArr, Class t, String splitStr) {
if (ValidatorUtil.isEmpty(list)) {
return new HashMap<>();
}
if (ValidatorUtil.isEmpty(splitStr)) {
splitStr = Constant.SPLIT_STR;
}
Map map = new HashMap<>(list.size());
T pkValue;
Class clazz = null;
Field[] fields = null;
Field[] superFields = null;
Method getMethod;
Map mapMethod = new HashMap<>();
if (clazz == null) {
clazz = list.get(0).getClass();
fields = list.get(0).getClass().getDeclaredFields();
superFields = list.get(0).getClass().getFields();
}
for (String pkStr : pkArr) {
getMethod = findMethod(pkStr, clazz, fields, superFields);
if (getMethod != null && mapMethod.get(pkStr) == null) {
mapMethod.put(pkStr, getMethod);
}
}
for (Obj obj : list) {
pkValue = getPkValue(pkArr, t, splitStr, fields, mapMethod, obj);
map.put(pkValue, obj);
}
return map;
}
/**
* List转为MapList，返回Map默认以“,”分隔
*
* @param list 待处理集合
* @param pk 主键
* @param
* @return
*/
public final static Map> list2MapList(List list, String pk) {
return list2MapList(list, pk, String.class);
}
/**
* List转为MapList，返回Map默认以“,”分隔
*
* @param list 待处理集合
* @param pk 主键
* @param 返回数据类型
* @param 集合数据类型
* @return
*/
public final static Map> list2MapList(List list, String pk, Class t) {
return list2MapList(list, new String[]{pk}, t, null);
}
/**
* List转为MapList，返回Map默认以“,”分隔
*
* @param list 待处理集合
* @param pkArr 主键集合
* @param splitStr Map键分隔符号
* @param 返回数据类型
* @param 集合数据类型
* @return
*/
public final static Map> list2MapList(List list, String[] pkArr, Class t, String splitStr) {
if (ValidatorUtil.isEmpty(list)) {
return new HashMap>();
}
if (ValidatorUtil.isEmpty(splitStr)) {
splitStr = Constant.SPLIT_STR;
}
Map> map = new HashMap<>();
T pkValue;
Class clazz = null;
Field[] fields = null;
Field[] superFields = null;
Method getMethod;
Map mapMethod = new HashMap<>();
List listNew;
if (clazz == null) {
clazz = list.get(0).getClass();
fields = list.get(0).getClass().getDeclaredFields();
superFields = list.get(0).getClass().getFields();
}
for (String pkStr : pkArr) {
getMethod = findMethod(pkStr, clazz, fields, superFields);
if (getMethod != null && mapMethod.get(pkStr) == null) {
mapMethod.put(pkStr, getMethod);
}
}
for (Object obj : list) {
pkValue = getPkValue(pkArr, t, splitStr, fields, mapMethod, obj);
if (ValidatorUtil.isNotEmpty(map.get(pkValue))) {
listNew = map.get(pkValue);
} else {
listNew = new ArrayList();
}
listNew.add(obj);
map.put(pkValue, listNew);
}
return map;
}
/**
* 将list中指定的key的值放到map中组装为信息list
*
* @param list
* @param keys
* @return
* @throws Exception
*/
public static List> list2ListMapByKeys(List list, String... keys) {
ValidatorUtil.validateNotEmpty(keys, "请出传入参数集合");
if (ValidatorUtil.isNotEmpty(list)) {
List> mapList = new ArrayList<>();
Map dataMap;
for (O o : list) {
dataMap = new HashMap<>(keys.length);
for (String key : keys) {
dataMap.put(key, ReflectionUtils.getFieldValue(o, key));
}
mapList.add(dataMap);
}
return mapList;
}
return new ArrayList<>();
}
/**
* 将list中移除指定的noKeys的值放到map中组装为信息list
*
* @param list
* @param noKeys
* @return
*/
public static List> list2ListMapPassKeys(List list, String... noKeys) {
Map noKeysMap = new HashMap<>();
if (ValidatorUtil.isNotEmpty(noKeys)) {
for (String noKey : noKeys) {
noKeysMap.put(noKey, noKey);
}
}
if (ValidatorUtil.isNotEmpty(list)) {
List> mapList = new ArrayList<>();
Map dataMap;
Field[] fields = null;
Field[] fieldsUse = null;
List fieldsList = new ArrayList<>();
if (fields == null) {
fields = list.get(0).getClass().getDeclaredFields();
for (Field field : fields) {
if (noKeysMap.get(field.getName()) != null) {
continue;
}
fieldsList.add(field);
}
}
for (O o : list) {
dataMap = new HashMap<>(noKeys.length);
for (Field field : fieldsList.toArray(fieldsUse)) {
dataMap.put(field.getName(), ReflectionUtils.getFieldValue(o, field.getName()));
}
mapList.add(dataMap);
}
return mapList;
}
return new ArrayList<>();
}
/**
* 获取集合字段值
*
* @param pkArr 主键集合
* @param t 返回类型
* @param splitStr Map键分隔符号
* @param fields 字段数组
* @param mapMethod
* @param obj
* @param
* @return
*/
private static T getPkValue(String[] pkArr, Class t, String splitStr, Field[] fields, Map mapMethod, Object obj) {
T pkValue = null;
if (ValidatorUtil.isNotEmpty(fields) && ValidatorUtil.isNotEmpty(pkArr)) {
for (String pkStr : pkArr) {
try {
pkValue = (T) (ValidatorUtil.isEmpty(pkValue) ? (T) Conver.parse(t, mapMethod.get(pkStr).invoke(obj))
: pkValue + splitStr + (T) Conver.parse(t, mapMethod.get(pkStr).invoke(obj)));
} catch (IllegalAccessException e) {
logger.error("不合法或不正确的参数", e);
} catch (InvocationTargetException e) {
logger.error("受查异常", e);
} catch (Exception e) {
logger.error("其他异常", e);
}
}
}
return pkValue;
}
/**
* 获取字段的方法
*
* @param pk
* @param clazz
* @param fields
* @param superFields
* @return
*/
private static Method findMethod(String pk, Class clazz, Field[] fields, Field[] superFields) {
PropertyDescriptor pd;
Method getMethod = null;
// 找到主键方法
if (getMethod == null) {
for (Field field : fields) {
if (pk.equals(field.getName())) {
try {
pd = new PropertyDescriptor(field.getName(), clazz);
getMethod = pd.getReadMethod();
break;
} catch (IllegalArgumentException e) {
logger.error("不合法或不正确的参数", e);
} catch (IntrospectionException e) {
logger.error("无法将字符串类名称映射到 Class 对象、无法解析字符串方法名，或者指定对其用途而言具有错误类型签名的方法名称", e);
} catch (Exception e) {
logger.error("其他异常", e);
}
}
}
}
// 本类没找到取父类找
if (getMethod == null) {
if (superFields != null && superFields.length > 0) {
for (Field field : superFields) {
if (pk.equals(field.getName())) {
try {
pd = new PropertyDescriptor(field.getName(), clazz);
getMethod = pd.getReadMethod();
} catch (IllegalArgumentException e) {
logger.error("不合法或不正确的参数", e);
} catch (IntrospectionException e) {
logger.error("无法将字符串类名称映射到 Class 对象、无法解析字符串方法名，或者指定对其用途而言具有错误类型签名的方法名称", e);
} catch (Exception e) {
logger.error("其他异常", e);
}
}
}
}
}
return getMethod;
}
/**
* list字符串拼接,默认以","分割
*
* @param list 待分割的字符串集合
* @return
*/
public static String list2Str(List list) {
return list2Str(list, SPLIT_STR);
}
/**
* list字符串拼接,默认以","分割
*
* @param list 待分割的字符串集合
* @return
*/
public static String list2StrPassEmpty(List list) {
return list2StrPassEmpty(list, SPLIT_STR);
}
/**
* list字符串拼接
*
* @param list 待分割的字符串集合
* @param splitStr 分割字符串
* @return
*/
public static String list2Str(List list, String splitStr) {
return list2Str(list, splitStr, false);
}
/**
* list字符串拼接
*
* @param list 待分割的字符串集合
* @param splitStr 分割字符串
* @return
*/
public static String list2StrPassEmpty(List list, String splitStr) {
return list2Str(list, splitStr, true);
}
/**
* list字符串拼接
*
* @param list 待分割的字符串集合
* @param splitStr 分割字符串
* @param passEmpty 是否忽略空字符串
* @return
*/
private static String list2Str(List list, String splitStr, boolean passEmpty) {
if (ValidatorUtil.isEmpty(list)) {
return "";
}
StringBuffer sf = new StringBuffer();
boolean isFirst = true;
for (String str : list) {
if (passEmpty && ValidatorUtil.isEmpty(str)) {
continue;
}
if (isFirst) {
isFirst = false;
} else {
sf.append(splitStr);
}
sf.append(str);
}
return sf.toString();
}
/**
* 拼接集合中字段对应的值，以","分隔，空的也拼接
*
* @param list 集合
* @param key 键值
* @param 字段泛型
* @return
*/
public static String list2StrByKey(List list, String key) {
return list2StrByKey(list, key, SPLIT_STR);
}
/**
* 拼接集合中字段对应的值，以","分隔，空的不拼接
*
* @param list 集合
* @param key 键值
* @param 字段泛型
* @return
*/
public static String list2StrByKeyPassEmpty(List list, String key) {
return list2StrByKeyPassEmpty(list, key, SPLIT_STR);
}
/**
* 拼接集合中字段对应的值，空的也拼接
*
* @param list 集合
* @param key 键值
* @param splitStr 分隔字符串
* @param 字段泛型
* @return
*/
public static String list2StrByKey(List list, String key, String splitStr) {
return list2StrByKey(list, key, splitStr, false);
}
/**
* 拼接集合中字段对应的值，空的不拼接
*
* @param list 集合
* @param key 键值
* @param splitStr 分隔字符串
* @param 字段泛型
* @return
*/
public static String list2StrByKeyPassEmpty(List list, String key, String splitStr) {
return list2StrByKey(list, key, splitStr, true);
}
/**
* 拼接集合中字段对应的值
*
* @param list 集合
* @param key 键值
* @param splitStr 分隔字符串
* @param passEmpty 是否忽略空的值
* @param
* @return
*/
private static String list2StrByKey(List list, String key, String splitStr, boolean passEmpty) {
if (ValidatorUtil.isEmpty(list)) {
return "";
}
StringBuffer sf = new StringBuffer();
boolean isFirst = true;
Object o;
for (T t : list) {
o = ReflectionUtils.getFieldValue(t, key);
if (passEmpty && ValidatorUtil.isEmpty(o)) {
continue;
}
if (isFirst) {
isFirst = false;
} else {
sf.append(splitStr);
}
sf.append(Conver.parse(String.class, o));
}
return sf.toString();
}
/**
* 方法名改为listRemoveSame
*
* @param list
* @return
*/
@Deprecated
public static List removeSameList(List list) {
return listRemoveSame(list);
}
/**
* 去除list中的重复元素
*
* @param list
* @return
*/
public static List listRemoveSame(List list) {
List newList = new ArrayList();
if (ValidatorUtil.isEmpty(list)) {
return newList;
}
Set h = new HashSet(list);
newList.addAll(h);
return newList;
}
public static Map strs2Map(String strs) {
return strs2Map(strs, SPLIT_STR);
}
public static Map strs2Map(String strs, String SplitStr) {
if (ValidatorUtil.isNotEmpty(strs)) {
String[] strArr = strs.split(SplitStr);
Map map = new HashMap();
for (String strIn : strArr) {
map.put(strIn, strIn);
}
return map;
}
return new HashMap<>();
}
public static List strs2List(String strs) {
return strs2List(strs, SPLIT_STR, String.class);
}
public static List strs2List(String strs, String SplitStr) {
return strs2List(strs, SplitStr, String.class);
}
public static List strs2List(String strs, String SplitStr, Class t) {
if (ValidatorUtil.isNotEmpty(strs)) {
String[] strArr = strs.split(SplitStr);
List list = new ArrayList<>();
for (String strIn : strArr) {
list.add((T) Conver.parse(t.getClass(), strIn));
}
return list;
}
return new ArrayList<>();
}
/**
* 获取map中所有key的集合
*
* @param map
* @return
*/
public static List mapKeys2List(Map map) {
if (ValidatorUtil.isNotEmpty(map)) {
List list = new ArrayList<>(map.size());
for (T key : map.keySet()) {
list.add(key);
}
return list;
}
return new ArrayList();
}
/**
* 分段
*
* @param list
* @param pageSize
* @return
*/
public final static List> splitList(List list, int pageSize) {
if (ValidatorUtil.isNotEmpty(list)) {
List> listArray = new ArrayList<>();
List subList = null;
for (int i = 0; i < list.size(); i++) {
if (i % pageSize == 0) {// 每次到达页大小的边界就重新申请一个subList
subList = new ArrayList<>();
listArray.add(subList);
}
subList.add(list.get(i));
}
return listArray;
}
return new ArrayList<>();
}
/**
* 获取主键集合,空的数据也获取
*
* @param list
* @param fieldName
* @param t
* @return
*/
public static List getListKeys(List list, String fieldName, Class t) {
return getListKeys(list, fieldName, t, false);
}
/**
* 获取主键集合,忽略空的数据
*
* @param list
* @param fieldName
* @param t
* @return
*/
public static List getListKeysPassEmpty(List list, String fieldName, Class t) {
return getListKeys(list, fieldName, t, true);
}
/**
* 获取主键集合
*
* @param list
* @param fieldName
* @param t
* @return
*/
private static List getListKeys(List list, String fieldName, Class t, boolean passEmpty) {
if (ValidatorUtil.isEmpty(list)) {
return new ArrayList<>();
}
List pkList = new ArrayList<>(list.size());
Object obj;
for (O entity : list) {
obj = ReflectionUtils.getFieldValue(entity, fieldName);
if (passEmpty && ValidatorUtil.isEmpty(obj)) {
continue;
}
pkList.add((T) obj);
}
return pkList;
}
/**
* 设置字段值
*
* @param list 主集合
* @param listDetail 子集合
* @param fieldTargetName 主集合和子集合关联的字段
* @param fieldSourceName 子集合和主集合关联的字段
* @param fieldPkName 子集合中关联主集合的字段
* @param t [参数说明]
* @return
*/
public static void setListValues(List list, List listDetail, String fieldTargetName,
String fieldSourceName, String fieldPkName, Class t) {
if (ValidatorUtil.isEmpty(list)) {
return;
}
Map> mapList = CollectionsUtil.list2MapList(listDetail, fieldSourceName, t);
for (O o : list) {
ReflectionUtils.setFieldValue(o, fieldTargetName,
mapList.get(ReflectionUtils.getFieldValue(o, fieldPkName)));
}
}
/**
* 获取集合的变化情况
*
* @param listOld 原集合
* @param listNew 新集合
* @param pk 主键
* @param passFilds 忽略比较的字段
* @return
*/
public final static ChangeResult getChangeByPk(String pk, List listOld, List listNew, String... passFilds) {
return getChangeByPkAndFiledsOrPassfileds(pk, listOld, listNew, false, passFilds);
}
/**
* 获取集合的变化情况
*
* @param listOld 原集合
* @param listNew 新集合
* @param pk 主键
* @param Fileds 比较的字段
* @return
*/
public final static ChangeResult getChangeByPkAndFileds(String pk, List listOld, List listNew,
String... Fileds) {
return getChangeByPkAndFiledsOrPassfileds(pk, listOld, listNew, true, Fileds);
}
/**
* 获取集合的变化情况
*
* @param listOld 原集合
* @param listNew 新集合
* @param pk 主键
* @param isFields 是否是比较字段
* @param Fileds isFields为1是该字段表示需要比较的字段，为0时表示忽略的字段
* @return
*/
private final static ChangeResult getChangeByPkAndFiledsOrPassfileds(String pk, List listOld, List listNew, boolean isFields, String... Fileds) {
// 获取新增修改及删除的数据
ChangeResult changeResult = new ChangeResult();
changeResult.setAddList(new ArrayList());
changeResult.setDelList(new ArrayList());
changeResult.setUpdateList(new ArrayList());
Map mapNew = new HashMap<>();
boolean isChange = false;
if (ValidatorUtil.isNotEmpty(listNew)) {
for (T entity : listNew) {
if (ValidatorUtil.isEmpty(ReflectionUtils.getFieldValue(entity, pk) + "")) {
changeResult.getAddList().add(entity);
isChange = true;
} else {
mapNew.put(ReflectionUtils.getFieldValue(entity, pk) + "", entity);
}
}
}
if (ValidatorUtil.isNotEmpty(listOld)) {
for (T entityIn : listOld) {
if (ValidatorUtil.isNotEmpty(mapNew.get(ReflectionUtils.getFieldValue(entityIn, pk) + ""))) {
if (isFields) {
if (BeanUtil.isNotEqualsByFields(entityIn, mapNew.get(ReflectionUtils.getFieldValue(entityIn, pk) + ""),
Fileds)) {
changeResult.getUpdateList().add(mapNew.get(ReflectionUtils.getFieldValue(entityIn, pk) + ""));
isChange = true;
}
} else {
if (BeanUtil.isNotEquals(entityIn, mapNew.get(ReflectionUtils.getFieldValue(entityIn, pk) + ""),
Fileds)) {
changeResult.getUpdateList().add(mapNew.get(ReflectionUtils.getFieldValue(entityIn, pk) + ""));
isChange = true;
}
}
} else {
changeResult.getDelList().add(entityIn);
isChange = true;
}
}
}
changeResult.setIsChange(isChange);
return changeResult;
}
/**
* 获取集合的变化情况
*
* @param key 字段
* @param listOld 原集合
* @param listNew 新集合
* @param passFilds 忽略比较的字段
* @return
*/
public final static ChangeResult getChangeByKey(String key, List listOld, List listNew,
String[] passFilds) {
return getChangeByKey(new String[]{key}, listOld, listNew, passFilds);
}
/**
* 获取集合的变化情况
*
* @param keys 字段 的集合
* @param listOld 原集合
* @param listNew 新集合
* @param passFilds 忽略比较的字段
* @return
*/
public final static ChangeResult getChangeByKey(String[] keys, List listOld, List listNew,
String[] passFilds) {
return getChangeByKeyAndFieldsOrPassfileds(keys, listOld, listNew, false,
passFilds);
}
/**
* 获取集合的变化情况
*
* @param key 字段 的集合
* @param listOld 原集合
* @param listNew 新集合
* @param fields 比较的字段
* @return
*/
public final static ChangeResult getChangeByKeyAndFields(String key, List listOld, List listNew,
String[] fields) {
return getChangeByKeyAndFieldsOrPassfileds(new String[]{key}, listOld, listNew, true,
fields);
}
/**
* 获取集合的变化情况
*
* @param keys 字段 的集合
* @param listOld 原集合
* @param listNew 新集合
* @param fields 比较的字段
* @return
*/
public final static ChangeResult getChangeByKeyAndFields(String[] keys, List listOld, List listNew,
String[] fields) {
return getChangeByKeyAndFieldsOrPassfileds(keys, listOld, listNew, true,
fields);
}
/**
* 获取集合的变化情况
*
* @param keys 字段 的集合
* @param listOld 原集合
* @param listNew 新集合
* @param isFields 是否是比较字段
* @param fields isFields为1是该字段表示需要比较的字段，为0时表示忽略的字段
* @return
*/
private final static ChangeResult getChangeByKeyAndFieldsOrPassfileds(String[] keys, List listOld, List listNew, boolean isFields,
String[] fields) {
// 获取新增修改及删除的数据
ChangeResult changeResult = new ChangeResult();
changeResult.setAddList(new ArrayList());
changeResult.setDelList(new ArrayList());
changeResult.setUpdateList(new ArrayList());
Map mapKey = new HashMap();
boolean isChange = false;
Map mapOld = getListValueByKeys(keys, listOld);
Map mapNew = getListValueByKeys(keys, listNew);
if (ValidatorUtil.isNotEmpty(mapOld)) {
for (String keyOld : mapOld.keySet()) {
if (ValidatorUtil.isEmpty(mapNew.get(keyOld))) {
changeResult.getDelList().add(mapOld.get(keyOld));// 删除
isChange = true;
} else {
if (isFields) {
if (ValidatorUtil.isEmpty(mapKey.get(keyOld))
&& BeanUtil.isNotEqualsByFields(mapOld.get(keyOld), mapNew.get(keyOld), fields)) {// 修改
changeResult.getUpdateList().add(mapNew.get(keyOld));
mapKey.put(keyOld, keyOld);
isChange = true;
}
} else {
if (ValidatorUtil.isEmpty(mapKey.get(keyOld))
&& BeanUtil.isNotEquals(mapOld.get(keyOld), mapNew.get(keyOld), fields)) {// 修改
changeResult.getUpdateList().add(mapNew.get(keyOld));
mapKey.put(keyOld, keyOld);
isChange = true;
}
}
}
}
}
if (ValidatorUtil.isNotEmpty(mapNew)) {
for (String keyNew : mapNew.keySet()) {
if (ValidatorUtil.isEmpty(mapOld.get(keyNew))) {
changeResult.getAddList().add(mapNew.get(keyNew));// 新增
isChange = true;
} else {
if (isFields) {
if (ValidatorUtil.isEmpty(mapKey.get(keyNew))
&& BeanUtil.isNotEqualsByFields(mapOld.get(keyNew), mapNew.get(keyNew), fields)) {// 修改
changeResult.getUpdateList().add(mapNew.get(keyNew));
mapKey.put(keyNew, keyNew);
isChange = true;
}
} else {
if (ValidatorUtil.isEmpty(mapKey.get(keyNew))
&& BeanUtil.isNotEquals(mapOld.get(keyNew), mapNew.get(keyNew), fields)) {// 修改
changeResult.getUpdateList().add(mapNew.get(keyNew));
mapKey.put(keyNew, keyNew);
isChange = true;
}
}
}
}
}
changeResult.setIsChange(isChange);
return changeResult;
}
private static Map getListValueByKeys(String[] keys, List listNew) {
if (ValidatorUtil.isEmpty(listNew)) {
return new HashMap<>();
}
Map mapNew = new HashMap<>(listNew.size());
if (ValidatorUtil.isNotEmpty(listNew)) {
List keyValues;
for (T entity : listNew) {
keyValues = new ArrayList<>();
for (String key : keys) {
keyValues.add(String.valueOf(ReflectionUtils.getFieldValue(entity, key)));
}
mapNew.put(CollectionsUtil.list2Str(keyValues), entity);
}
}
return mapNew;
}
/**
* 获取集合中的最大值(值不能含有空的)
*
* @param list 待处理的集合
* @return
*/
public static > O getMaxValue(List list) {
return getMaxOrMinValue(true, false, list, null, null);
}
/**
* 获取集合中的最小值(值不能含有空的)
*
* @param list 待处理的集合
* @return
*/
public static > O getMinValue(List list) {
return getMaxOrMinValue(false, false, list, null, null);
}
/**
* 获取集合中的最大值(值不能含有空的)
*
* @param list 待处理的集合
* @param key 字段名
* @param o 返回类型
* @return
*/
public static > O getMaxValue(List list, String key, Class o) {
return getMaxOrMinValue(true, false, list, key, o);
}
/**
* 获取集合中的最小值(值不能含有空的)
*
* @param list 待处理的集合
* @param key 字段名
* @param o 返回类型
* @return
*/
public static > O getMinValue(List list, String key, Class o) {
return getMaxOrMinValue(false, false, list, key, o);
}
/**
* 获取集合中的最大值，排除空元素
*
* @param list 待处理的集合
* @return
*/
public static > O getMaxValuePassEmpty(List list) {
return getMaxOrMinValue(true, true, list, null, null);
}
/**
* 获取集合中的最小值，排除空元素
*
* @param list 待处理的集合
* @return
*/
public static > O getMinValuePassEmpty(List list) {
return getMaxOrMinValue(false, true, list, null, null);
}
/**
* 获取集合中的最大值，排除空元素
*
* @param list 待处理的集合
* @param key 字段名
* @param o 返回类型
* @return
*/
public static > O getMaxValuePassEmpty(List list, String key, Class o) {
return getMaxOrMinValue(true, true, list, key, o);
}
/**
* 获取集合中的最小值，排除空元素
*
* @param list 待处理的集合
* @param key 字段名
* @param o 返回类型
* @return
*/
public static > O getMinValuePassEmpty(List list, String key, Class o) {
return getMaxOrMinValue(false, true, list, key, o);
}
private static > O getMaxOrMinValue(boolean needMax, boolean passEmpty, List list, String key, Class o) {
if (ValidatorUtil.isEmpty(list)) {
return null;
}
List listValue = new ArrayList(list.size());
Object obj;
for (T t : list) {
if (key == null) {
obj = t;
} else {
obj = (O) ReflectionUtils.getFieldValue(t, key);
}
if (passEmpty && ValidatorUtil.isEmpty(obj)) {
continue;
} else if (!passEmpty && ValidatorUtil.isEmpty(obj)) {
throw new ValidateException("元素不能为空:" + t.toString());
}
listValue.add((O) obj);
}
if (needMax) {
return getMaxOrMin(listValue, true);
} else {
return getMaxOrMin(listValue, false);
}
}
private static > O getMaxOrMin(Collection col, boolean needMax) {
Iterator ite = col.iterator();// 先通过迭代器一个个拿出来
O obj = ite.next();// 得到集合中的第一个对象
while (ite.hasNext())// 将得到的第一个对象和下一个对象比较
{
O object = ite.next();// 得到小一个
int num = obj.compareTo(object);// 得到比较结果
if (needMax) {
if (num < 0) { // 如果是小于0返回比较，得到最大值
obj = object;
}
} else {
if (num > 0) {
obj = object;
}
}
}
return obj;
}
}