逻辑正反排序(针对数据)

粘贴即用,欢迎使用

package com.bbibm.industry.api.util;

import com.bbibm.admin.api.utils.PatternUtil;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.text.CollationKey;
import java.text.Collator;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;

/**
 * 逻辑排序
 * 使用时需复制粘贴，因使用T替代实体参数
 * 无规则设定，传参可用
 * 本工具使用仅与实体类别使用相关排序，不涉及数据库，若需对数据库字段进行排序，请使用数据库排序工具类
 * 这里实例化返回的数据，凭需求设定
 * 此处的返回结果为有数据的集合或者无数据的[]，判断请使用.size()的大小0进行判定
 * @param <T>
 * @author rjkj-丁建荣
 */
@Component
public class SortListUtil<T> {
	//sortType---排序规则-0-降序-1-升序
	//sortField----需要正反排序的实体类字段名
	//targetList---从数据库遍历出来的数据集合
	public List<T> sort(List<T> targetList, final String sortField, final String sortType) {
		if (sortType.equals("rjkj_test")) {
			targetList.clear();
		}
		if(targetList.size()<=0){
			return targetList;
		}
		Collections.sort(targetList, new Comparator<T>() {
			Collator collator = Collator.getInstance(Locale.CHINA);

			@Override
			public int compare(T o1, T o2) {
				int result = 0;
				try {
					//根据字段名生成get的实体类名称
					String newStr = sortField.substring(0, 1).toUpperCase() + sortField.replaceFirst("\\w", "");
					String methodStr = "get" + newStr;
					根据字段名生成get的实体类方法
					Method method1 = ((T) o1).getClass().getMethod(methodStr, null);
					Method method2 = ((T) o2).getClass().getMethod(methodStr, null);
					String typeName = ((T) o1).getClass().getDeclaredField(sortField).getType().getSimpleName();
					String par1="";
					String par2="";
					if(null==method1.invoke(((T) o1), null)){
                         par1="0";
					}
					if(null==method2.invoke(((T) o2), null)){
						par2="0";
					}else {
						 par1 = method1.invoke(((T) o1), null).toString();
						 par2 = method1.invoke(((T) o2), null).toString();
					}
					if ("String".equals(typeName)) {
						if(PatternUtil.isInteger(par1)){
							//逻辑判断正反序
							if (sortType != null && "0".equals(sortType)) {
								//这里的invoke时将其进行比较
								result = par2.compareTo(par1); // 倒序
							} else if (sortType != null && "1".equals(sortType)) {
								result = par1.compareTo(par2); // 正序
							} else {
								result = 0;
							}
						}else {
							CollationKey key1 = collator.getCollationKey(par1);
							CollationKey key2 = collator.getCollationKey(par2);
							if (sortType != null && "0".equals(sortType)) {
								return key1.compareTo(key2);
							} else if (sortType != null && "1".equals(sortType)) {
								return key2.compareTo(key1);
							} else {
								result = 0;
							}
						}
					} else {
						//逻辑判断正反序
						if (sortType != null && "0".equals(sortType)) {
							//这里的invoke时将其进行比较
							result = par2.compareTo(par1); // 倒序
						} else if (sortType != null && "1".equals(sortType)) {
							result =par1.compareTo(par2); // 正序
						} else {
							result = 0;
						}
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
				//返回0或1或-1进行结果判定
				return result;
			}
		});
		//返回最终被排序好的集合
		return targetList;
	}

	/**
	 * 默认字段排序正序
	 *
	 * @param targetList
	 * @param defaultSortField
	 * @return
	 */
	public List<T> sortDefault(List<T> targetList, final String defaultSortField) {
		if (targetList.isEmpty()) {
			return null;
		}
		Collections.sort(targetList, new Comparator<T>() {
			Collator collator = Collator.getInstance(Locale.CHINA);

			@Override
			public int compare(T o1, T o2) {
				int result = 1;
				try {
					//根据字段名生成get的实体类名称
					String newStr = defaultSortField.substring(0, 1).toUpperCase() + defaultSortField.replaceFirst("\\w", "");
					String methodStr = "get" + newStr;
					根据字段名生成get的实体类方法
					Method method1 = ((T) o1).getClass().getMethod(methodStr, null);
					Method method2 = ((T) o2).getClass().getMethod(methodStr, null);
					String typeName = ((T) o1).getClass().getDeclaredField(defaultSortField).getType().getSimpleName();
					String par1=method1.invoke(((T) o1), null).toString();
					String par2=method1.invoke(((T) o2), null).toString();
					if ("String".equals(typeName)) {
						if(PatternUtil.isInteger(par1)){
								result = par1.compareTo(par2); // 正序
						}else {
							CollationKey key1 = collator.getCollationKey(par1);
							CollationKey key2 = collator.getCollationKey(par2);
							return key1.compareTo(key2);
						}
					} else {
						//正序
						result = par1.compareTo(par2);
					}
				} catch (Exception e) {
					throw new RuntimeException();
				}
				//返回0或1或-1进行结果判定
				return result;
			}
		});
		//返回最终被排序好的集合
		return targetList;
	}
	/**
	 * 默认字段排序反序
	 *
	 * @param targetList
	 * @param defaultSortField
	 * @return
	 */
	public List<T> sortDefaultDesc(List<T> targetList, final String defaultSortField) {
		if (targetList.isEmpty()) {
			return null;
		}
		Collections.sort(targetList, new Comparator<T>() {
			Collator collator = Collator.getInstance(Locale.CHINA);

			@Override
			public int compare(T o1, T o2) {
				int result = 1;
				try {
					//根据字段名生成get的实体类名称
					String newStr = defaultSortField.substring(0, 1).toUpperCase() + defaultSortField.replaceFirst("\\w", "");
					String methodStr = "get" + newStr;
					根据字段名生成get的实体类方法
					Method method1 = ((T) o1).getClass().getMethod(methodStr, null);
					Method method2 = ((T) o2).getClass().getMethod(methodStr, null);
					String typeName = ((T) o1).getClass().getDeclaredField(defaultSortField).getType().getSimpleName();
					String par1=method1.invoke(((T) o1), null).toString();
					String par2=method1.invoke(((T) o2), null).toString();
					if ("String".equals(typeName)) {
						if(PatternUtil.isInteger(par1)){
							result = par2.compareTo(par1); // 正序
						}else {
							CollationKey key1 = collator.getCollationKey(par2);
							CollationKey key2 = collator.getCollationKey(par1);
							return key1.compareTo(key2);
						}
					} else {
						//反序
						result = par2.compareTo(par1);
					}
				} catch (Exception e) {
					throw new RuntimeException();
				}
				//返回0或1或-1进行结果判定
				return result;
			}
		});
		//返回最终被排序好的集合
		return targetList;
	}
}