对象的任意属性对list进行排序的公共类

package com.easycom.util;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.poi.ss.formula.functions.T;

public class CommonUtil {
//属性的类型集合（基本类型）
public static String GENERICTYPES[] = {"class java.lang.Integer", "int",
"class java.lang.Double", "double", "class java.lang.Boolean", "boolean",
"class java.lang.Float", "float", "class java.lang.Character", "char",
"class java.lang.short", "short", "class java.lang.Byte", "byte",
"class java.lang.Long", "long",
"class java.lang.String", "class java.util.Date"};

//根据对象属性的名称，而对list进行排序
public List<T> sortByName( String sort, boolean orderBl, List<T> list){
	//检查是否合法
	if ( list.size() <= 0 || sort == null || "".equals(sort) ) {
		return list;
	}
	//获得getter或is方法名称
	Map<String, Object> map = getMethodName( sort , list.get(0));
	if ( map == null) {
		return list;
	}
	String name = map.get("name").toString();
	int indexType = (int)map.get("indexType");
	
	//开始排序
	List<T> newList = new ArrayList<T>();
	try{
		T t;
		while(list.size()>0){
			t = list.get(0);
			Object oldValue = (Object)t.getClass().getMethod(name).invoke(t);
			int index = 0;
			if(oldValue != null) {
				for(int j = 1; j < list.size();j++){
					Object newValue = (Object)list.get(j).getClass().getMethod(name).invoke(list.get(j));
					if(newValue == null){
						t = list.get(j);
						index = j;
						break;
					}
					int temp  = compareAllType(oldValue, newValue, indexType);
					if(orderBl){
						if(temp > 0){
							t = list.get(j);
							oldValue = (Object)t.getClass().getMethod(name).invoke(t);
							index = j;
						}
					}else{
						if(temp < 0){
							t = list.get(j);
							oldValue = (Object)t.getClass().getMethod(name).invoke(t);
							index = j;
						}
					}
				}
			}
			newList.add(t);
			list.remove(index);
		}
	}catch(Exception e){
		e.printStackTrace();
	}
	
	return newList;
}

public int compareAllType(Object oldValue, Object newValue, int indexType){
	int temp = 0;
	if( indexType < 16 ) {
		indexType = indexType >>> 1;
		switch (indexType) {
		//int
		case 0:
			temp = (int)oldValue-(int)newValue;
			break;
		//double
		case 1:
			if((double)oldValue>(double)newValue){
				temp = 1;
			}else if((double)oldValue>(double)newValue){
				temp = -1;
			}else{
				temp = 0;
			}
			break;
		//boolean	
		case 2:
			if((boolean)oldValue) {
				temp = 1;
			} else {
				temp = -1;
			}
			break;
		//float	
		case 3:
			if((float)oldValue>(float)newValue){
				temp = 1;
			}else if((float)oldValue>(float)newValue){
				temp = -1;
			}else{
				temp = 0;
			}
			break;
		//char
		case 4:
			if((char)oldValue>(char)newValue){
				temp = 1;
			}else if((char)oldValue>(char)newValue){
				temp = -1;
			}else{
				temp = 0;
			}
			break;
		//short
		case 5:
			if((short)oldValue>(short)newValue){
				temp = 1;
			}else if((short)oldValue>(short)newValue){
				temp = -1;
			}else{
				temp = 0;
			}
			break;
		//byte
		case 6:
			if((byte)oldValue>(byte)newValue){
				temp = 1;
			}else if((byte)oldValue>(byte)newValue){
				temp = -1;
			}else{
				temp = 0;
			}
			break;
		//long
		case 7:
			if((long)oldValue>(long)newValue){
				temp = 1;
			}else if((long)oldValue>(long)newValue){
				temp = -1;
			}else{
				temp = 0;
			}
			break;
		//其他情况不排序
		default:
			temp = 0;
			break;
		}
	} else {
		switch (indexType) {
		//String
		case 16:
			temp = oldValue.toString().compareTo(newValue.toString());
			break;
		//Date
		case 17:
			Date oldDate = (Date)oldValue;
			Date newDate = (Date)newValue;
			if(oldDate.getTime() > newDate.getTime()){
				temp = 1;
			}else if(oldDate.getTime() < newDate.getTime()){
				temp = -1;
			}else{
				temp = 0;
			}
			break;
		//其他情况不排序
		default:
			temp = 0;
			break;
		}
	}
	return temp;
}

//判断实体中是否存在该属性，存在，则搜索出指针
public int validSort( String sort, T t) {
	Field[] flds = t.getClass().getDeclaredFields(); 
	int index = -1;
	if ( flds != null ){  
        for ( int i = 0; i < flds.length; i++ ){
        	if(sort.equals(flds[i].getName())){
        		index = i;
        		break;
        	}
        }  
    }  
	return index;
}

//获得属性类型的指针
public int validType( String type ) {
	int index = -1;
	for ( int i = 0; i < GENERICTYPES.length ; i++ ) {
		if ( GENERICTYPES[i].equals( type ) ){
			index = i;
			break;
		}
	}
	return index;
}

//获得T对象中的getter或is方法名称
public Map<String, Object> getMethodName( String name, T t){
	//是否存在函数名
	Field[] flds = t.getClass().getDeclaredFields(); 
	int indexName = validSort( name, t );
	if( indexName <= -1){
		return null;
	}
	
	//是否存在该数据类型
	int indexType = validType ( flds[indexName].getGenericType().toString() );
	if ( indexType <= -1 ) {
		return null;
	}
	
	Map<String, Object> map = new HashMap<String, Object>();
	map.put( "indexType", indexType );
	//构造方法名
	name = name.substring(0,1).toUpperCase() + name.substring(1);
	if( "boolean".equals( GENERICTYPES[indexType] ) ) {
		name = "is" + name;
	}else{
		name = "get" + name;
	}
	map.put( "name", name );
	return map;
}

//根据属性的类型type、方法的名称、及该对象，获得该属性的值
public T valueByType ( String type, String name, T t){
	
	return null;
}


public static void main(String[] agrs){
	Date date =  new Date();
	int j = 10;
	Object bObject = j;
	System.out.println(bObject);
}

}