Java List 通用排序工具类

时间：2025-03-10 10:29:19

场景：Java 类 需 重新排序，有时升序、有时倒序，有时是按照多字段排序

功能描述：

1.支持 对象的一个属性或多个属性进行排序.
2.支持 对象属性正序和倒序排列.

3.支持 数字字符类型的List排序

4.泛型实现，结合Comparable接口， 支持多类型数据格式 

代码：

package GenericTest;

import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;


/**
 * [简述]:List通用排序工具类
 * User: xyj
 * Date:2016/7/2
 * Time:10:24
 * To change this template use File | Settings | File Templates.
 */
public class ListSortUtil {


    private static final String SORT_ASC = "asc";


    private static final String SORT_DESC = "desc";


    /**
     * [简述]： 对List数组排序
     * @param list 源数据 排序集合
     * @param sort 升序 还是 降序，默认升序
     * @return List
     */
    public static List<?> sort(List<?> list,final String sort){
        (list, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                int ret = 0;
                if(o1 instanceof Integer){
                    ret = ((Integer)o1).compareTo((Integer)o2);
                } else if(o1 instanceof Double){
                    ret = ((Double)o1).compareTo((Double)o2);
                } else if(o1 instanceof Long){
                    ret = ((Long)o1).compareTo((Long)o2);
                } else if(o1 instanceof Float){
                    ret = ((Float)o1).compareTo((Float)o2);
                } else if(o1 instanceof Date){
                    ret = ((Date)o1).compareTo((Date) o2);
                } else if(isDouble((o1)) && isDouble((o2))){
                    ret = (new Double(())).compareTo(new Double(()));
                } else {
                    ret = (o1).compareTo((o2));
                }
                if(null != sort && SORT_DESC.equalsIgnoreCase(sort)){
                    return -ret;
                }else{
                    return ret;
                }
            }
        });
        return list;
    }


    /**
     *[简述]: List 泛型 排序
     * @param list 源数据 排序集合
     * @param field 排序的数据字段名称
     * @param sort 升序 还是 降序，默认升序
     * @param <T> 泛型T
     * @return List
     */
    public static <T> List<T> sort(List<T> list,final String field,final String sort){
        (list, new Comparator<T>() {
            @Override
            public int compare(T o1, T o2) {
                int ret = 0;
                try {
                    Method method1 = ().getDeclaredMethod(getMethodName(field),null);
                    Method method2 = ().getDeclaredMethod(getMethodName(field), null);
                    Field field1 = ().getDeclaredField(field);
                    (true);
                    Class<?> type = ();
                    if(type == ){
                        ret = ((Integer)(o1)).compareTo((Integer)(o2));
                    } else if(type == ){
                        ret = ((Double)(o1)).compareTo((Double)(o2));
                    } else if(type == ){
                        ret = ((Long)(o1)).compareTo((Long)(o2));
                    } else if(type == ){
                        ret = ((Float)(o1)).compareTo((Float)(o2));
                    } else if(type == ){
                        ret = ((Date)(o1)).compareTo((Date) (o2));
                    } else if(isDouble(((o1))) && isDouble(((o2)))){
                        ret = (new Double((o1).toString())).compareTo(new Double((o2).toString()));
                    } else {
                        ret = ((o1)).compareTo(((o2)));
                    }


                } catch (IllegalAccessException e) {
                    ();
                } catch (NoSuchFieldException e) {
                    ();
                } catch (NoSuchMethodException e) {
                    ();
                } catch (InvocationTargetException e) {
                    ();
                }
                if(null != sort && SORT_DESC.equalsIgnoreCase(sort)){
                    return  -ret;
                }else{
                    return ret;
                }
            }
        });
        return list;
    }


    private static boolean isDouble(String str){
        boolean flag = false;
        if(isInteger(str) || isFloat(str)){
            flag = true;
        }
        return flag;
    }


    private static boolean isInteger(String str){
        Matcher matcher = ("^[+-]?[0-9]+$").matcher(str);
        return ();
    }


    private static boolean isFloat(String str){
        return ("[\\d]+\\.[\\d]+");
    }


    /**
     *[简述]: List 泛型 排序
     * @param list 源数据 排序集合
     * @param fields 排序的数据字段名称
     * @param sorts 升序 还是 降序
     * @param <T> 泛型T
     * @return List
     */
    public static <T> List<T> sort(List<T> list,final String [] fields,final String [] sorts){
        if(null != fields &&  > 0){
            for(int index = 0;index < ;index ++){
                String sortRule = SORT_ASC;
                if(null != sorts &&  >= index && null != sorts[index]){
                    sortRule = sorts[index];
                }
                final String sort = sortRule;
                final String field = fields[index];
                (list, new Comparator<T>() {
                    @Override
                    public int compare(T o1, T o2) {
                        int ret = 0;
                        try {
                            Method method1 = ().getDeclaredMethod(getMethodName(field),null);
                            Method method2 = ().getDeclaredMethod(getMethodName(field), null);
                            Field field1 = ().getDeclaredField(field);
                            (true);
                            Class<?> type = ();
                            if(type == ){
                                ret = ((Integer)(o1)).compareTo((Integer)(o2));
                            } else if(type == ){
                                ret = ((Double)(o1)).compareTo((Double)(o2));
                            } else if(type == ){
                                ret = ((Long)(o1)).compareTo((Long)(o2));
                            } else if(type == ){
                                ret = ((Float)(o1)).compareTo((Float)(o2));
                            } else if(type == ){
                                ret = ((Date)(o1)).compareTo((Date) (o2));
                            } else if(isDouble(((o1))) && isDouble(((o2)))){
                                ret = (new Double((o1).toString())).compareTo(new Double((o2).toString()));
                            } else {
                                ret = ((o1)).compareTo(((o2)));
                            }


                        } catch (NoSuchMethodException e) {
                            ();
                        } catch (InvocationTargetException e) {
                            ();
                        } catch (IllegalAccessException e) {
                            ();
                        } catch (NoSuchFieldException e) {
                            ();
                        }
                        if(null != sort && SORT_DESC.equalsIgnoreCase(sort)){
                            return  -ret;
                        }else{
                            return ret;
                        }
                    }
                });
            }
        }
        return list;
    }


    private static String getMethodName(String str){
        StringBuffer name = new StringBuffer();
        name = ("get").append(firstLetterToCapture(str));
        return ();
    }


    private static String firstLetterToCapture(String name){
        char[] arr = ();
        arr[0] -= 32;
        return (arr);
    }


}

测试类： 

package ;

import ;
import ;
import ;

import ;
import ;
import ;

/**
 * Created by with IntelliJ IDEA.
 * User:xyj
 * Date:2016/7/11
 * Time:17:21
 * To change this template use File | Settings | File Templates.
 */
@ContextConfiguration("classpath:spring/")
public class TestListSort extends AbstractTestNGSpringContextTests{

    @Test
    public void testListSortNumberString(){
        List<String> arrays = new ArrayList<String>();
        ("2");
        ("13");
        ("4.5");
        ("26");
        List<String> afterSortArrays = (List<String>) (arrays, "asc");
        for(String s:afterSortArrays){
            ((s));
        }
    }

    @Test
    public void testListSortString(){
        List<String> arrays = new ArrayList<String>();
        ("ac");
        ("cd");
        ("ab");
        ("bf");
        ("bfd");
        ("bg");
        ("ba");
        List<String> afterSortArrays = (List<String>) (arrays, "asc");
        for(String s:afterSortArrays){
            ((s));
        }
    }

    @Test
    public void testListSortNumber(){
        List<Integer> arrays = new ArrayList<Integer>();
        (12);
        (56);
        (2);
        (-5);
        (21);
        (0);
        List<Integer> afterSortArrays = (List<Integer>) (arrays, "asc");
        for(Integer s:afterSortArrays){
            ((s));
        }
    }

    @Test
    public void testListSortDouble() {
        List<Double> arrays = new ArrayList<Double>();
        (-0.12);
        (-0.102);
        (12.0);
        (0.0);
        (9.2);
        (-1.2);
        (-1.20001);
        (3.0);
        (31.0);
        List<Double> afterSortArrays = (List<Double>) (arrays, "asc");
        for(Double s:afterSortArrays){
            ((s));
        }
    }

    @Test
    public void testListSortDate(){
        List<Date> arrays = new ArrayList<Date>();
        (("2015-01-12",DateUtil.DATE_FORMAT_EN));
        (("2015-11-12",DateUtil.DATE_FORMAT_EN));
        (("2015-12-12",DateUtil.DATE_FORMAT_EN));
        (("2015-02-12",DateUtil.DATE_FORMAT_EN));
        (("2015-06-12",DateUtil.DATE_FORMAT_EN));
        (("2015-10-12",DateUtil.DATE_FORMAT_EN));
        (("2015-10-31",DateUtil.DATE_FORMAT_EN));
        (("2015-10-02",DateUtil.DATE_FORMAT_EN));
        List<Date> afterSortArrays = (List<Date>) (arrays, "asc");
        for(Date s:afterSortArrays){
            ((DateUtil.date2Str(s,DateUtil.DATE_FORMAT_EN)));
        }
    }

}

测试类 Two:

package ;

import org.;
import org.;
import ;
import ;
import ;
import ;
import ;

import ;
import ;

/**
 * Created by with IntelliJ IDEA.
 * User:xyj
 * Date:2016/7/11
 * Time:14:48
 * To change this template use File | Settings | File Templates.
 */

@ContextConfiguration("classpath:spring/")
public class TestListSortUtils extends AbstractTestNGSpringContextTests{

    private static final Logger logger = ();

    List<SysUser> sysUsers = new ArrayList<SysUser>();

    private List<SysUser> getUsers(){
        List<SysUser> sysUsers = new ArrayList<SysUser>();

        SysUser sysUser3 = new SysUser();
        ("12");
        ("naver");
        ("4");
        ("15153");
        (2);
        (sysUser3);

        SysUser sysUser2 = new SysUser();
        ("3");
        ("Tex");
        ("3");
        ("415151");
        (2);
        (sysUser2);

        SysUser sysUser0 = new SysUser();
        ("1");
        ("tommy");
        ("1");
        ("123456");
        (1);
        (sysUser0);

        SysUser sysUser1 = new SysUser();
        ("2");
        ("tony");
        ("2");
        ("5621232");
        (1);
        (sysUser1);

        return sysUsers;
    }

    @BeforeClass
    public void setInitBeforeSortList(){
        sysUsers = getUsers();
        ("before sort ：");
        for(SysUser sysUser:sysUsers){
            ("sysUser: pkid: [ " + () + " ]"
                    + " userCode: [ "+ () + " ]"
                    + " contact: [ "+ () + " ]"
            );
        }
    }



    @Test
    public void testListSort(){
        List<SysUser> afterSysUsers  = (sysUsers,"loginName",null);
        ("after sort ：");
        for(SysUser sysUser:afterSysUsers){
            ("sysUser: pkid: [ " + () + " ]"
                    + " userCode: [ "+ () + " ]"
                     + " contact: [ "+ () + " ]"
            );
        }
    }

    @AfterClass
    public void destroy(){
        ("运行结束！");
    }


}
测试 Three: 

package ;

import org.;
import org.;
import ;
import ;
import ;
import ;
import ;

import ;
import ;

/**
 * Created by with IntelliJ IDEA.
 * User:xyj
 * Date:2016/7/11
 * Time:14:48
 * To change this template use File | Settings | File Templates.
 */

@ContextConfiguration("classpath:spring/")
public class TestListSortOrderUtils extends AbstractTestNGSpringContextTests{

    private static final Logger logger = ();

    List<SysUser> sysUsers = new ArrayList<SysUser>();

    private List<SysUser> getUsers(){
        List<SysUser> sysUsers = new ArrayList<SysUser>();

        SysUser sysUser3 = new SysUser();
        ("12");
        ("naver");
        ("4");
        ("15153");
        (2);
        (sysUser3);

        SysUser sysUser2 = new SysUser();
        ("3");
        ("Tex");
        ("3");
        ("415151");
        (2);
        (sysUser2);

        SysUser sysUser0 = new SysUser();
        ("1");
        ("tommy");
        ("1");
        ("123456");
        (1);
        (sysUser0);

        SysUser sysUser1 = new SysUser();
        ("2");
        ("tony");
        ("2");
        ("5621232");
        (1);
        (sysUser1);

        return sysUsers;
    }

    @BeforeClass
    public void setInitBeforeSortList(){
        sysUsers = getUsers();
        ("before sort ：");
        for(SysUser sysUser:sysUsers){
            ("sysUser: pkid: [ " + () + " ]"
                    + " userCode: [ "+ () + " ]"
                    + " contact: [ "+ () + " ]"
            );
        }
    }



    @Test
    public void testListSort(){
        List<SysUser> afterSysUsers  = (sysUsers,new String[] {"pkid","contact"},new String[] {"asc","desc"});
        ("after sort ：");
        for(SysUser sysUser:afterSysUsers){
            ("sysUser: pkid: [ " + () + " ]"
                    + " userCode: [ "+ () + " ]"
                     + " contact: [ "+ () + " ]"
            );
        }
    }

    @AfterClass
    public void destroy(){
        ("运行结束！");
    }


}


相关文章