对象的任意属性对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);
}

}

转载于:https://www.cnblogs.com/TanMG/p/5601187.html