Java对象排序

java中系统提供的排序实现:

Comparator接口–> Collections.sort(List, new ComparaObject());

需要实现 Comparator接口 远没有iOS中系统api调用来的简单

1
2
3
/// iOS中
NSSortDescriptor *descriptor = [[NSSortDescriptor alloc] initWithKey:@"createTime" ascending:YES];
NSArray* allMsgs = [allMessage sortedArrayUsingDescriptors:@[descriptor]];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/// java中
public class ComparaObject implements Comparator<User>{

	@Override
	public int compare(User o1, User o2) {
    
		  String user1_name = StringUtil.toHanyuPinyin(o1.getName());
		  String user2_name = StringUtil.toHanyuPinyin(o2.getName());
		
		  int b_photo = o1.getIsHavePhoto().compareTo(o2.getIsHavePhoto());
		  int b_contact = o1.getIsContact().compareTo(o2.getIsContact());
		  int b_name = user1_name.compareTo(user2_name);
		  
       
         if (b_photo ==0) { //先按照是否有照片排序
                   
        	   if(b_contact == 0) {//再按照是否是联系人排
  			   return b_name;
  			}else  {
  				return -b_contact;  //最后按照name的拼音升序
  			}
		}else {
			return -b_photo;
		}
	}
}

利用快速排序实现类似iOS方法的工具类方法实现:

1,调用

1
2
3
4
5
6
 List<SortDescription> sortDesList = new ArrayList<SortDescription>(); 
sortDesList.add(new SortDescription("isHavePhoto",false));       //根据isHavePhoto降序
sortDesList.add(new SortDescription("isContact",false));         //根据isContact降序
sortDesList.add(new SortDescription("name",true));               //根据name升序

Collections.sort(users, new ComparaObject(sortDesList));

2,代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Comparator;
import java.util.List;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;


class SortDescription {
	
	private String fildName;
	private Boolean isAsc;
	
	
	public SortDescription(String fildName, Boolean isAsc) {
		super();
		this.fildName = fildName;
		this.isAsc = isAsc;
	}


	public String getFildName() {
		return fildName;
	}


	public void setFildName(String fildName) {
		this.fildName = fildName;
	}


	public Boolean getIsAsc() {
		return isAsc;
	}


	public void setIsAsc(Boolean isAsc) {
		this.isAsc = isAsc;
	}

}

public class ComparaObject implements Comparator<Object>{

	private List<SortDescription> sortDesList;

	public List<SortDescription> getSortDesList() {
		return sortDesList;
	}

	public void setSortDesList(List<SortDescription> sortDesList) {
		this.sortDesList = sortDesList;
	}

	public ComparaObject(List<SortDescription> sortDesList) {
		super();
		this.sortDesList = sortDesList;
	}

	int comparaTwoObj(SortDescription des, Object o1, Object o2) {
		
		String value1 = null;
		String value2 = null;
		 try {
			 value1 = hendleReturnValue(o1, des.getFildName());
			 value2 = hendleReturnValue(o2, des.getFildName());
			 
		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		int compara =  toHanyuPinyin(value1).compareTo(toHanyuPinyin(value2));
		
		return compara;
	}
	
	private String hendleReturnValue(Object obj, String fildName) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		
		String methodName = "get" + fildName.substring(0, 1).toUpperCase() + fildName.substring(1);  
		
		 Object obj1 = InvokeWithObj(obj, methodName, null);
		 if (obj1 instanceof String) {
			 return  (String) obj1;
		}else {
			return  obj1 + "";
		}
	}
	
	@Override
	public int compare(Object o1, Object o2) {
		
	for (int i = 0; i < this.sortDesList.size(); i++) {
		
		SortDescription des = this.sortDesList.get(i);
		
	    int compara = comparaTwoObj(des, o1, o2);
		
	    if (compara != 0) {
			return des.getIsAsc() == true ? compara : -compara;
		}else {
		   continue;	
		}
	}	
	return 0;
  }

	
	 //根据对象,方法名,参数调用方法
	   private Object InvokeWithObj (Object obj, String methodName, Object ...args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
	      
			    Class prams[] =  getPramsClass(args);
				Method method = getKindOfClassMethod(obj.getClass(),methodName,prams);
				method.setAccessible(true); //设置可以访问私有方法
				Object returnObj = method.invoke(obj, args);
				return  returnObj;
		 } 
	   //根据参数对象数组获取参数类数组
	   private Class[] getPramsClass ( Object ...args){
			
			if (args == null) {
				return null;
			}
			
			 Class[] prams = new Class[args.length];
				for (int i = 0; i < args.length; i++) {
					prams[i] = args[i].getClass();
				}
				return prams;
		} 
	    //获取类的指定方法,子类没有向父类找 
		 private Method getKindOfClassMethod(Class cls, String methodName, Class[] prams) {
				
		       Method method = null;
		       Class clazz = cls;
		       while (method == null && clazz != Object.class) {
			      try {
				     method = clazz.getDeclaredMethod(methodName, prams);	
			      } catch (NoSuchMethodException e) {
				     e.printStackTrace();
				     clazz = clazz.getSuperclass();
			     } 
		   }
		     return method;
	 } 
		 private String toHanyuPinyin(String ChineseLanguage){
			 if (ChineseLanguage == null) {
				return "";
			}
		        char[] cl_chars = ChineseLanguage.trim().toCharArray();
		        String hanyupinyin = "";
		        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
		        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);// 输出拼音全部小写
		        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);// 不带声调
		        defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V) ;
		        try {
		            for (int i=0; i<cl_chars.length; i++){
		                if (String.valueOf(cl_chars[i]).matches("[\u4e00-\u9fa5]+")){// 如果字符是中文,则将中文转为汉语拼音
		                    hanyupinyin += PinyinHelper.toHanyuPinyinStringArray(cl_chars[i], defaultFormat)[0];
		                } else {// 如果字符不是中文,则不转换
		                    hanyupinyin += cl_chars[i];
		                }
		            }
		        } catch (BadHanyuPinyinOutputFormatCombination e) {
		            System.out.println("字符不能转成汉语拼音");
		        }

		        return hanyupinyin;
		    }
}

#利用快速排序实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
public class JMQuickSort {

	private static List<JMSortDes> sortDesList;
	
	public List<JMSortDes> getSortDesList() {
		return sortDesList;
	}
	public void setSortDesList(List<JMSortDes> sortDesList) {
		JMQuickSort.sortDesList = sortDesList;
	}
	
	public static <T> void quickSort(List<JMSortDes> sortDesList, List<T> objects) {
		
		JMQuickSort.sortDesList = sortDesList;
		
		sort(objects, 0, objects.size()-1);
	}
	//快速排序
	private static <T> void sort(List<T> objects, int left, int right){
			
			if (left >= right) {  return; }
			
			int i = left, j = right;
			T obj = objects.get(left);
			
			while(i < j) {
				
				while(i < j && objectCompara(obj, objects.get(j)) <= 0) {
					j--;
				}
				T usj = objects.get(j);
				objects.remove(i);
				objects.add(i, usj);
				
				while(i < j && objectCompara(obj, objects.get(i)) >= 0) {
					i++;
				}
				T usi = objects.get(i);
				objects.remove(j);
				objects.add(j, usi);
			}
			objects.remove(i);
			objects.add(i, obj);
			
			sort(objects, left, i-1);
			sort(objects, i+1, right);
		}
		
		static int objectCompara(Object o1, Object o2) {
			//大于0--->o1大
	    	for (int i = 0; i < JMQuickSort.sortDesList.size(); i++) {
	    		
	    		JMSortDes des = JMQuickSort.sortDesList.get(i);
	    		
	    	    int compara = comparaTwoObj(des, o1, o2);
	    		
	    	    if (compara != 0) {
	    			return des.getIsAsc() == true ? compara : -compara;
	    		}else {
	    		   continue;	
	    		}
	    	}
			return 0;
	 }
		private static int comparaTwoObj(JMSortDes des, Object o1, Object o2) {
			
			String value1 = null;
			String value2 = null;
			 try {
				 value1 = hendleReturnValue(o1, des.getFildName());
				 value2 = hendleReturnValue(o2, des.getFildName());
				 
			} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			int compara =  toHanyuPinyin(value1).compareTo(toHanyuPinyin(value2));
			
			return compara;
		}
		private static String hendleReturnValue(Object obj, String fildName) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
			
			String methodName = "get" + fildName.substring(0, 1).toUpperCase() + fildName.substring(1);  
			
			 Object obj1 = InvokeWithObj(obj, methodName, null);
			 if (obj1 instanceof String) {
				 return  (String) obj1;
			}else {
				return  obj1 + "";
			}
		}
		 private static String toHanyuPinyin(String ChineseLanguage){
			 if (ChineseLanguage == null) {
				return "";
			}
		        char[] cl_chars = ChineseLanguage.trim().toCharArray();
		        String hanyupinyin = "";
		        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
		        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);// 输出拼音全部小写
		        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);// 不带声调
		        defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V) ;
		        try {
		            for (int i=0; i<cl_chars.length; i++){
		                if (String.valueOf(cl_chars[i]).matches("[\u4e00-\u9fa5]+")){// 如果字符是中文,则将中文转为汉语拼音
		                    hanyupinyin += PinyinHelper.toHanyuPinyinStringArray(cl_chars[i], defaultFormat)[0];
		                } else {// 如果字符不是中文,则不转换
		                    hanyupinyin += cl_chars[i];
		                }
		            }
		        } catch (BadHanyuPinyinOutputFormatCombination e) {
		            System.out.println("字符不能转成汉语拼音");
		        }

		        return hanyupinyin;
		    }
		 //根据对象,方法名,参数调用方法
		   private static Object InvokeWithObj (Object obj, String methodName, Object ...args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		      
			   Class[] prams = null;
			   if (args != null) {
				   prams = new Class[args.length];
				   if (args != null) {
					   for (int i = 0; i < args.length; i++) {
							prams[i] = args[i].getClass();
						}
					}
			   }
				   Method method = null;
			       Class clazz = obj.getClass();
			       while (method == null && clazz != Object.class) {
				      try {
					     method = clazz.getDeclaredMethod(methodName, prams);	
				      } catch (NoSuchMethodException e) {
					     e.printStackTrace();
					     clazz = clazz.getSuperclass();
				     } 
			   }
					method.setAccessible(true); //设置可以访问私有方法
					Object returnObj = method.invoke(obj, args);
					return  returnObj;
			 } 

}

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true