Java通用工具类之按对象属性排序工具类

本工具类为按对象属性排序工具类,实现的功能:
1.按对象的一个属性和多个属性进行排序.
2.按对象属性正序和倒序排列.
3.完美支持int等基础类和Integer等包装类.
4.完美支持属性为实现了Comparable接口的类.
5.如果类不是java.lang中定义的基础类型也没有实现Comparable接口则转为String后进行排序.

实现思路:使用反射取得对象属性或对象方法的值从而解除对具体对象的依赖.

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;/*** 通用工具类之按对象中某属性排序* @author 李坤 * 交流博客:http://blog.csdn.net/lk_blog*/
public class SortListUtil {public static final String DESC = "desc";public static final String ASC = "asc";/*** 对list中的元素按升序排列.* * @param list*            排序集合* @param field*            排序字段* @return*/public static List<?> sort(List<?> list, final String field) {return sort(list, field, null);}/*** 对list中的元素进行排序.* * @param list*            排序集合* @param field*            排序字段* @param sort*            排序方式: SortList.DESC(降序) SortList.ASC(升序).* @return*/@SuppressWarnings("unchecked")public static List<?> sort(List<?> list, final String field,final String sort) {Collections.sort(list, new Comparator() {public int compare(Object a, Object b) {int ret = 0;try {Field f = a.getClass().getDeclaredField(field);f.setAccessible(true);Class<?> type = f.getType();if (type == int.class) {ret = ((Integer) f.getInt(a)).compareTo((Integer) f.getInt(b));} else if (type == double.class) {ret = ((Double) f.getDouble(a)).compareTo((Double) f.getDouble(b));} else if (type == long.class) {ret = ((Long) f.getLong(a)).compareTo((Long) f.getLong(b));} else if (type == float.class) {ret = ((Float) f.getFloat(a)).compareTo((Float) f.getFloat(b));} else if (type == Date.class) {ret = ((Date) f.get(a)).compareTo((Date) f.get(b));} else if (isImplementsOf(type, Comparable.class)) {ret = ((Comparable) f.get(a)).compareTo((Comparable) f.get(b));} else {ret = String.valueOf(f.get(a)).compareTo(String.valueOf(f.get(b)));}} catch (SecurityException e) {e.printStackTrace();} catch (NoSuchFieldException e) {e.printStackTrace();} catch (IllegalArgumentException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}if (sort != null && sort.toLowerCase().equals(DESC)) {return -ret;} else {return ret;}}});return list;}/*** 对list中的元素按fields和sorts进行排序,* fields[i]指定排序字段,sorts[i]指定排序方式.如果sorts[i]为空则默认按升序排列.* * @param list* @param fields* @param sorts* @return*/@SuppressWarnings("unchecked")public static List<?> sort(List<?> list, String[] fields, String[] sorts) {if (fields != null && fields.length > 0) {for (int i = fields.length - 1; i >= 0; i--) {final String field = fields[i];String tmpSort = ASC;if (sorts != null && sorts.length > i && sorts[i] != null) {tmpSort = sorts[i];}final String sort = tmpSort;Collections.sort(list, new Comparator() {public int compare(Object a, Object b) {int ret = 0;try {Field f = a.getClass().getDeclaredField(field);f.setAccessible(true);Class<?> type = f.getType();if (type == int.class) {ret = ((Integer) f.getInt(a)).compareTo((Integer) f.getInt(b));} else if (type == double.class) {ret = ((Double) f.getDouble(a)).compareTo((Double) f.getDouble(b));} else if (type == long.class) {ret = ((Long) f.getLong(a)).compareTo((Long) f.getLong(b));} else if (type == float.class) {ret = ((Float) f.getFloat(a)).compareTo((Float) f.getFloat(b));} else if (type == Date.class) {ret = ((Date) f.get(a)).compareTo((Date) f.get(b));} else if (isImplementsOf(type, Comparable.class)) {ret = ((Comparable) f.get(a)).compareTo((Comparable) f.get(b));} else {ret = String.valueOf(f.get(a)).compareTo(String.valueOf(f.get(b)));}} catch (SecurityException e) {e.printStackTrace();} catch (NoSuchFieldException e) {e.printStackTrace();} catch (IllegalArgumentException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}if (sort != null && sort.toLowerCase().equals(DESC)) {return -ret;} else {return ret;}}});}}return list;}/*** 默认按正序排列* * @param list* @param method* @return*/public static List<?> sortByMethod(List<?> list, final String method) {return sortByMethod(list, method, null);}@SuppressWarnings("unchecked")public static List<?> sortByMethod(List<?> list, final String method,final String sort) {Collections.sort(list, new Comparator() {public int compare(Object a, Object b) {int ret = 0;try {Method m = a.getClass().getMethod(method, null);m.setAccessible(true);Class<?> type = m.getReturnType();if (type == int.class) {ret = ((Integer) m.invoke(a, null)).compareTo((Integer) m.invoke(b, null));} else if (type == double.class) {ret = ((Double) m.invoke(a, null)).compareTo((Double) m.invoke(b, null));} else if (type == long.class) {ret = ((Long) m.invoke(a, null)).compareTo((Long) m.invoke(b, null));} else if (type == float.class) {ret = ((Float) m.invoke(a, null)).compareTo((Float) m.invoke(b, null));} else if (type == Date.class) {ret = ((Date) m.invoke(a, null)).compareTo((Date) m.invoke(b, null));} else if (isImplementsOf(type, Comparable.class)) {ret = ((Comparable) m.invoke(a, null)).compareTo((Comparable) m.invoke(b, null));} else {ret = String.valueOf(m.invoke(a, null)).compareTo(String.valueOf(m.invoke(b, null)));}if (isImplementsOf(type, Comparable.class)) {ret = ((Comparable) m.invoke(a, null)).compareTo((Comparable) m.invoke(b, null));} else {ret = String.valueOf(m.invoke(a, null)).compareTo(String.valueOf(m.invoke(b, null)));}} catch (NoSuchMethodException ne) {System.out.println(ne);} catch (IllegalAccessException ie) {System.out.println(ie);} catch (InvocationTargetException it) {System.out.println(it);}if (sort != null && sort.toLowerCase().equals(DESC)) {return -ret;} else {return ret;}}});return list;}@SuppressWarnings("unchecked")public static List<?> sortByMethod(List<?> list, final String methods[],final String sorts[]) {if (methods != null && methods.length > 0) {for (int i = methods.length - 1; i >= 0; i--) {final String method = methods[i];String tmpSort = ASC;if (sorts != null && sorts.length > i && sorts[i] != null) {tmpSort = sorts[i];}final String sort = tmpSort;Collections.sort(list, new Comparator() {public int compare(Object a, Object b) {int ret = 0;try {Method m = a.getClass().getMethod(method, null);m.setAccessible(true);Class<?> type = m.getReturnType();if (type == int.class) {ret = ((Integer) m.invoke(a, null)).compareTo((Integer) m.invoke(b, null));} else if (type == double.class) {ret = ((Double) m.invoke(a, null)).compareTo((Double) m.invoke(b, null));} else if (type == long.class) {ret = ((Long) m.invoke(a, null)).compareTo((Long) m.invoke(b, null));} else if (type == float.class) {ret = ((Float) m.invoke(a, null)).compareTo((Float) m.invoke(b, null));} else if (type == Date.class) {ret = ((Date) m.invoke(a, null)).compareTo((Date) m.invoke(b, null));} else if (isImplementsOf(type, Comparable.class)) {ret = ((Comparable) m.invoke(a, null)).compareTo((Comparable) m.invoke(b,null));} else {ret = String.valueOf(m.invoke(a, null)).compareTo(String.valueOf(m.invoke(b, null)));}} catch (NoSuchMethodException ne) {System.out.println(ne);} catch (IllegalAccessException ie) {System.out.println(ie);} catch (InvocationTargetException it) {System.out.println(it);}if (sort != null && sort.toLowerCase().equals(DESC)) {return -ret;} else {return ret;}}});}}return list;}/*** 判断对象实现的所有接口中是否包含szInterface* * @param clazz* @param szInterface* @return*/public static boolean isImplementsOf(Class<?> clazz, Class<?> szInterface) {boolean flag = false;Class<?>[] face = clazz.getInterfaces();for (Class<?> c : face) {if (c == szInterface) {flag = true;} else {flag = isImplementsOf(c, szInterface);}}if (!flag && null != clazz.getSuperclass()) {return isImplementsOf(clazz.getSuperclass(), szInterface);}return flag;}public static void main(String[] args) throws Exception {List<Student> list = new ArrayList<Student>();list.add(new Student(3, "b", 1, new Date(11110000)));list.add(new Student(1, "c", 3, new Date(44440000)));list.add(new Student(2, "a", 2, new Date(22210000)));list.add(new Student(4, "a", 11, new Date(33330000)));System.out.println("-------原来序列-------------------");for (Student stu : list) {System.out.println(stu.toString());}// 按age正序排序,注意结果排完后是1,2,3,11. 不是1,11,2,3(如果是String类型正序排序是这样)SortListUtil.sort(list, "age", null);System.out.println("---------测试Integer和正序,按age正序排序-----------------");for (Student stu : list) {System.out.println(stu.toString());}// 按id倒序SortListUtil.sort(list, "id", SortListUtil.DESC);System.out.println("--------测试int和倒序,按id倒序------------------");for (Student stu : list) {System.out.println(stu.toString());}// 先按name正序排序,再按id正序排序SortListUtil.sort(list, new String[] { "name", "id" }, new String[] {});System.out.println("---------测试多个排序字段,先按name正序,name相同时再按id正序-----------------");for (Student stu : list) {System.out.println(stu.toString());}// 先按name正序排序,再按id倒序排序SortListUtil.sort(list, new String[] { "name", "id" }, new String[] {SortListUtil.ASC, SortListUtil.DESC });System.out.println("---------测试多个排序字段,先按name正序,name相同时再按id倒序-----------------");for (Student stu : list) {System.out.println(stu.toString());}// 按birthday排序SortListUtil.sort(list, "birthday");System.out.println("---------测试实现了Comparable接口的对象排序,按birthday正序-----------------");for (Student stu : list) {System.out.println(stu.toString());}// sortByMethodSortListUtil.sortByMethod(list, "getId", null);System.out.println("---------测试sortByMethod,按getId方法正序-----------------");for (Student stu : list) {System.out.println(stu.toString());}}
}

测试执行效果:

Studeng.java:

import java.util.*;public class Student{private int id;private String name;private Integer age;private Date birthday;public Student(int id, String name, Integer age, Date birthday) {super();this.id = id;this.name = name;this.age = age;this.birthday = birthday;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}public Date getBirthday() {return birthday;}public void setBirthday(Date birthday) {this.birthday = birthday;}@Overridepublic String toString() {return "Student [id=" + id + ", name=" + name + ", age=" + age+ ", birthday=" + birthday + "]";}}

以下关于Comparable和Comparator的基础知识摘自博客:http://uule.iteye.com/blog/766688

1.Comparable接口是在java.lang类中的，而Comparator接口是在java.util类中的。
2.Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。

用自定义类实现 Comparable接口，那么这个类就具有排序功能，Comparable和具体你要进行排序的类的实例邦定。

而Comparator比较灵活，它没有和任何类绑定，实现它的自定义类仅仅定义了一种排序方式或排序规则。不言而喻，这种方式比较灵活。我们的要排序的类可以分别和多个实现 Comparator接口的类绑定，从而达到可以按自己的意愿实现按多种方式排序的目的。Comparable——“静态绑定排序”,Comparator——“动态绑定排序”。

限于本人水平有限,很多地方写的并不完美,希望大家不吝赐教.不足之处欢迎留言交流,希望在和大家的交流中得到提高.

Java通用工具类之按对象属性排序工具类相关推荐

结合自定义注解，java反射和comparator实现对象的排序
开头一注:本代码是在学习comparator时,想到是否能写一个排序的工具类,在思考过后决定结合注解来实现排序,目前代码还比较粗犷,请大神指教,请大家轻喷. 一.新增自定义注解 @Documented ...
java 文件拷贝保留原来的属性_Java常用属性拷贝工具类使用总结
开头聊几句 1.网上很多的技术文章和资料是有问题的,要学会辨证的看待,不能随便就拿来用,起码要自己验证一下 2.关注当下,关注此刻,如果你真正阅读本篇文章,请花几分钟时间的注意力阅读,相信你会有收获的 ...
java自定义注解实现校验对象属性是否为空
前面学习了如何自定义一个注解:java如何优雅的自定义一个注解下面来实战演示一下如何使用自定义注解做一些实际的功能.比如校验对象属性是否为空. 一.自定义一个NotNull注解我们自定义一个Not ...
json对象数组按对象属性排序
//json对象数组按对象属性排序 function JsonSort(obj, field, sortby) {this.obj = obj;this.field = field;this.sort ...
JAVA 排序工具类
提供了以下排序: 冒泡排序选择排序插入排序希尔排序快速排序归并排序桶排序堆排序 package com.xingej.algorithm.sort;import java.util.Ar ...
java 工具类sort_Java 通用排序工具类ListSortUtils
场景:Java 类需重新排序,有时升序.有时倒叙,有时是多字段排序代码: package GenericTest; import java.lang.reflect.InvocationTarg ...
java堆排序工具包_JAVA 排序工具类
提供了以下排序:冒泡排序选择排序插入排序希尔排序快速排序归并排序桶排序堆排序 package com.xingej.algorithm.sort;import java.util.Arr ...
java工具类源码阅读,java学习日记第二天（实用的工具类和源码解析一Arrays）
本帖最后由三木猿于 2020-9-18 11:17 编辑每日名言学者须先立志.今日所以悠悠者,只是把学问不曾做一件事看,遇事则且胡乱恁地打过了,此只是志不立. --朱熹工作中经常会用到一些工 ...
java中使用jxl导出excel表格的工具类（全网唯一亲测可用，在原来基础上扩展）
java中后台导出excel的话,有两种方案,一是使用poi(不过由于是windows版本的,存在不兼容,但功能更多,更强大),而是使用jxl(纯java编写,不过兼容,简单一些),可以设置输出的ex ...

Java通用工具类之按对象属性排序工具类

Java通用工具类之按对象属性排序工具类相关推荐

最新文章

热门文章