Android项目中我们常常需要封装一些方便于开发项目的工具类，最近笔者项目中需要对List集合进行排序，归类整理等需求，以前笔者的写法就是为每一个List里面元素的每一个属性写一个排序算法，当然Set集合做到排序很方便，但是Set集合有一点就是不能放入重复的元素。因此，为了让代码变得方便高雅一点，笔者对Java泛型和反射进行充分的研究，于是封装了一个ListUtils类，它可以做到对任何元素的任何属性进行排序，归类整理，当然这个属性必须是八大基本类型加String类型，闲话不多说，咱们直接上代码：
对任意的List集合进行排序,笔者使用的冒泡排序，如果你想用其它的，请自行更改，关键是要学会自己封装：
/**
* 可以对任意的List集合进行排序
* @param list 要排序的集合
* @param sortShuXing 要排序的对应的属性，比如：学生的年龄
* @param <T> 泛型对应元素的类型
* @return 排序完成之后的List集合
*/
public <T> List<T> sortAnyList(List<T> list, String sortShuXing) {
if (list == null||list.size() == 0) {
return list;
}
Field byteField1 = null;
String shuXingType = "";
try {
byteField1 = list.get(0).getClass().getDeclaredField(sortShuXing);
shuXingType = byteField1.getType().getName();
byteField1.setAccessible(true);
} catch (NoSuchFieldException | SecurityException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
for (int i = 0; i < list.size() - 1; i++) {
for (int j = i + 1; j < list.size(); j++) {
try {
switch (shuXingType) {
case "byte":
case "short":
case "int":
case "long":
case "char":
long b1 = 0;
long b2 = 0;
b1 = byteField1.getLong(list.get(i));
b2 = byteField1.getLong(list.get(j));
if (b1 >= b2) {
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
break;
case "float":
case "double":
double d1 = 0;
double d2 = 0;
d1 = byteField1.getDouble(list.get(i));
d2 = byteField1.getDouble(list.get(j));
if (d1 >= d2) {
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
break;
case "String":
String s1 = "";
String s2 = "";
s1 = (String) byteField1.get(list.get(i));
s2 = (String) byteField1.get(list.get(j));
System.out.println(s1 + ":" + s2);
break;
default:
if(byteField1.getType() == Byte.class ){
Byte byte1 = (Byte) byteField1.get(list.get(i));
Byte byte2 = (Byte) byteField1.get(list.get(j));
if(byte1.byteValue() >= byte2.byteValue()){
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
}else if(byteField1.getType() == Short.class){
Short short1 = (Short) byteField1.get(list.get(i));
Short short2 = (Short) byteField1.get(list.get(j));
if(short1.shortValue() >= short2.shortValue()){
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
}else if(byteField1.getType() == Integer.class){
Integer integer1 = (Integer) byteField1.get(list.get(i));
Integer integer2 = (Integer) byteField1.get(list.get(j));
if(integer1.intValue() >= integer2.intValue()){
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
}else if(byteField1.getType() == Long.class){
Long long1 = (Long) byteField1.get(list.get(i));
Long long2 = (Long) byteField1.get(list.get(j));
if(long1.longValue() >= long2.longValue()){
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
}else if(byteField1.getType() == Float.class){
Float float1 = (Float) byteField1.get(list.get(i));
Float float2 = (Float) byteField1.get(list.get(j));
if(float1.floatValue() >= float2.floatValue()){
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
}else if(byteField1.getType() == Double.class){
Double double1 = (Double) byteField1.get(list.get(i));
Double double2 = (Double) byteField1.get(list.get(j));
if(double1.doubleValue() >= double2.doubleValue()){
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
}else if(byteField1.getType() == Character.class){
Character character1 = (Character) byteField1.get(list.get(i));
Character character2 = (Character) byteField1.get(list.get(j));
if(character1.charValue() >= character2.charValue()){
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
}else if(byteField1.getType() == String.class){
String string1 = (String) byteField1.get(list.get(i));
String string2 = (String) byteField1.get(list.get(j));
int length = string1.length()<=string2.length()?string1.length():string2.length();
boolean falg = false;
for(int m=0;m<length;m++){
if(string1.charAt(m) > string2.charAt(m)){
falg = true;
break;
}else if(string1.charAt(m) < string2.charAt(m)){
falg = false;
break;
}
if(m == length-1&&!falg){
falg = string1.length()>=string2.length()?true:false;
}
}
if(falg){
T t = list.get(i);
list.set(i, list.get(j));
list.set(j, t);
}
}
}
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return list;
}
归类整理算法：
/**
* @param traget 要整理的目标集合 比如：List<Music>
* @param tragetShuXingName 要整理的目标集合内部元素对应的属性名字 比如：singerName
* @param resultClass 整理成什么样的类型 比如:Singer.class
* @param resultShuxingName 整理类型对应的属性名字 比如：name
* @param resultListShuXingName 整理后的集合 比如：musics
* @param <T> 被整理的集合的内部元素类型 比如:Singer
* @param <E> 整理后的集合的内部元素类型 比如：Music
* @return 返回整理完成后的集合，比如：List<Singer>
*/
public <T,E> List<T> zhengLi(List<E> traget,String tragetShuXingName,Class resultClass,String resultShuxingName,String resultListShuXingName){
List<T> results = new ArrayList<>();
if(traget == null || traget.size() == 0){
return null;
}
Field field= null;
try {
field = traget.get(0).getClass().getDeclaredField(tragetShuXingName);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
for(int i = 0;i<traget.size();i++){
//这个地方获取目标的值
try {
switch (field.getType().getName()) {
case "byte":
case "short":
case "int":
case "long":
case "char":
break;
case "float":
case "double":
break;
case "String":
break;
default:
if (field.getType() == Byte.class) {
} else if (field.getType() == Short.class) {
} else if (field.getType() == Integer.class) {
} else if (field.getType() == Long.class) {
} else if (field.getType() == Float.class) {
} else if (field.getType() == Double.class) {
} else if (field.getType() == Character.class) {
} else if (field.getType() == String.class) {
String s1 = "";
s1 = (String) field.get(traget.get(i));
boolean isNewAdd = true;
T t = null;
for(int j = 0;j<results.size();j++){
//比较结果集合中是否存在这个元素
t = results.get(j);
String resultValue = (String) t.getClass().getDeclaredField(resultShuxingName).get(results.get(j));
if((s1!=null&&resultValue!=null)&&s1.equals(resultValue)){
isNewAdd = false;
//得到t的e整理集合
List<E> eList = (List<E>) t.getClass().getDeclaredField(resultListShuXingName).get(results.get(j));
eList.add(traget.get(i));
break;
}
}
if(isNewAdd){
//添加这个元素到目标元素
t = (T) resultClass.newInstance();
List<E> eList = new ArrayList<>();
eList.add(traget.get(i));
Field field1 = t.getClass().getDeclaredField(resultListShuXingName);
field1.set(t,eList);
Field field2 = t.getClass().getDeclaredField(resultShuxingName);
field2.set(t,s1);
results.add(t);
}
}
}
}catch (IllegalAccessException e){
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
return results;
}
以上整理算法，目前笔者只写了String类型的整理，其它的写上感觉没什么用途意义，如果有需要，请自行添加逻辑。下面是Demo：
链接：https://pan.baidu.com/s/1yj1tyz7-VcCqRuMv42i1FA 密码：2fks