Android 列表按照时间排序

  =================================2015年10月21日15:25:46  更新时间===============

新增同时按照3个字段来进行排序的例子如下：

Collections.sort(dataMap, new Comparator<Map<String, Object>>() {

			@Override
			public int compare(Map<String, Object> lhs, Map<String, Object> rhs) {
				switch (whichsort) {
				case System_OpenPosition_Sort_Currency:

					String d2 = ((String) rhs.get(Instrument));
					String d1 = (String) lhs.get(Instrument);
					if (d2 != null && d1 != null) {

						int flag = d1.compareTo(d2);
						if (flag == 0) {
							Double d3 = ((Double) rhs.get(OpenPrice));
							Double d4 = (Double) lhs.get(OpenPrice);
							if (d3 != null && d4 != null) {

								int flag2 = d4.compareTo(d3);
								if (flag2 == 0) {
									String d5 = ((String) rhs.get(BuySell));
									String d6 = (String) lhs.get(BuySell);
									if (d5 != null && d6 != null) {

										return d6.compareTo(d5);
									}
								}

								return d4.compareTo(d3);
							}
						} else {
							return flag;
						}
						// return d1.compareTo(d2);
					}

  项目中在listview展示历史记录，需求是要按照时间来排序，其实原理很简单，只要将绑定的数据先进行排序，然后放到listview里面填充展示就可以了，解决方案如下：

    排序方法如下：

   

	/**
	 * 通过时间来进行倒序
	 */
	private void sortOrderHisByTime() {
		if (maps.isEmpty()) {//这个maps就是listview绑定的数据源，排序是用这个来进行的。
			return;
		}
			@Override
			public int compare(Map<String, Object> lhs, Map<String, Object> rhs) {
				return ((Date) rhs.get(CloseTime)).compareTo((Date) lhs
						.get(CloseTime));
			}
		});
	}

       按照上述的方法，就可以按照时间进行排序。

       

    转载的对于Collections.sort的原理解释，感谢这位前辈：http://trinea.iteye.com/blog/1248517

常需要对list进行排序，小到List<String>，大到对自定义的类进行排序。不需要自行归并或堆排序。简单实现一个接口即可。

本文先会介绍利用Collections对List<String>进行排序，继而讲到Collections.sort的原理，

再讲到如何对自定义类进行排序，

最后会介绍利用Collections sort对自定义对象进行排序的另外一种方法，并将两种排序进行了简单的性能比较。

下文中提到的如何追踪Collections等类的ava源代码，可以参考：http://trinea.iteye.com/blog/1351233

 

1、对List<String>排序及Collections.sort的原理

代码如下

Java代码  

1. List<String> stringList = new ArrayList<String>();  
2. stringList.add("nice");  
3. stringList.add("delicious");  
4. stringList.add("able");  
5. stringList.add("moon");  
6. stringList.add("try");  
7. stringList.add("friend");  
8.   
9. Collections.sort(stringList);  
10.   
11. for (String str : stringList) {  
12.     System.out.println(str);  
13. }  

其中Collections为java.util.Collections。

查看Collections中的sort实现

Java代码  

1. @SuppressWarnings("unchecked")  
2. public static <T extends Comparable<? super T>> void sort(List<T> list) {  
3.     Object[] array = list.toArray();  
4.     Arrays.sort(array);  
5.     int i = 0;  
6.     ListIterator<T> it = list.listIterator();  
7.     while (it.hasNext()) {  
8.         it.next();  
9.         it.set((T) array[i++]);  
10.     }  
11. }  

 从中可以看出排序主体为Arrays.sort(array);Arrays的sort实现为

Java代码  

1. public static void sort(Object[] array) {  
2.     // BEGIN android-changed  
3.     ComparableTimSort.sort(array);  
4.     // END android-changed  
5. }  

继续追踪，ComparableTimSort的sort实现ComparableTimSort.sort

static void sort(Object[] a)到static void sort(Object[] a, int lo, int hi)到private static void binarySort(Object[] a, int lo, int hi, int start)。在binarySort中用于大小比较部分为

Java代码  

1. Comparable<Object> pivot = (Comparable) a[start];  
2. int left = lo;  
3. int right = start;  
4. assert left <= right;  
5.   
6. while (left < right) {  
7.     int mid = (left + right) >>> 1;  
8.     if (pivot.compareTo(a[mid]) < 0)  
9.         right = mid;  
10.     else  
11.         left = mid + 1;  
12. }  

会调用Object的compareTo进行比较。而默认类似String和Integer类型都已经覆盖compareTo方法。所以可以自行进行比较

 

2、对自定义类进行比较

通过上面的介绍了解了Collections排序的原理，下面介绍下自定义对象的排序，先查看下Integer和String的比较原理、然后介绍如何对自定义类进行比较

  2.1 我们查看Object的实现发现其中并没有compareTo方法，

再看下Integer定义

Java代码  

1. public final class Integer extends Number implements Comparable<Integer>  

再看下String的定义

Java代码  

1. public final class String implements java.io.Serializable, Comparable<String>, CharSequence  

 我们可以发现他们都继承自Comparable

 

  2.2 查看Comparable接口

可以发现Comparable中只有一个方法

Java代码  

1. public int compareTo(T o);  

也就是说实际上binarySort方法中调用的是Comparable的compareTo方法，以此可知只要继承自Comparable，

并实现compareTo即可调用Collections.sort对自定义对象进行排序

 

  2.3 自定义类的比较

下面代码为对User进行排序，首先按姓名字母先后排序，若姓名相同，则按年龄由小到大排序

Java代码  

1. public class MainTest {  
2.   
3.     public static void main(String[] args) {  
4.         List<User> userList = new ArrayList<User>();  
5.         userList.add(new User("Lucy", 19));  
6.         userList.add(new User("Jack", 19));  
7.         userList.add(new User("Jim", 19));  
8.         userList.add(new User("James", 19));  
9.         userList.add(new User("Herry", 19));  
10.         userList.add(new User("Luccy", 19));  
11.         userList.add(new User("James", 18));  
12.         userList.add(new User("Herry", 20));  
13.   
14.         Collections.sort(userList);  
15.   
16.         for (User user : userList) {  
17.             System.out.println(user.getName() + "\t\t" + user.getAge());  
18.         }  
19.     }  
20.   
21.     private static class User implements Comparable<User> {  
22.   
23.         private String name;  
24.         private int    age;  
25.   
26.         public User(String name, int age){  
27.             this.name = name;  
28.             this.age = age;  
29.         }  
30.   
31.         @Override  
32.         public int compareTo(User another) {  
33.             int compareName = this.name.compareTo(another.getName());  
34.             if (compareName == 0) {  
35.                 return (this.age == another.getAge() ? 0 : (this.age > another.getAge() ? 1 : -1));  
36.             }  
37.             return compareName;  
38.         }  
39.   
40.         public String getName() {  
41.             return name;  
42.         }  
43.   
44.         public int getAge() {  
45.             return age;  
46.         }  
47.     }  
48. }  

执行后输出为：

Xml代码  

1. Herry       19  
2. Herry       20  
3. Jack        19  
4. James       18  
5. James       19  
6. Jim     19  
7. Luccy       19  
8. Lucy        19  

可以看出只需两点即可

a、继承自Comparable

Java代码  

1. private static class User implements Comparable<User>  

b、实现compareTo方法

上面的public int compareTo(User another)为比较的主体

可以看到其中int compareName = this.name.compareTo(another.getName());表示比较姓名

若大于返回1，等于返回0，小于会返回-1。

若相等则按照int age的大小进行比较。

上面的大于返回1，等于返回0，小于会返回-1也是用来binarySort比较的依据。

 

3、利用Collectionssort的重载函数对自定义对象进行排序

代码如下，仍同2中的一样先比较姓名，若相等再比较年龄输出

Java代码  

1. public class MainTest {  
2.   
3.     public static void main(String[] args) {  
4.         List<User> userList = new ArrayList<User>();  
5.         userList.add(new User("Lucy", 19));  
6.         userList.add(new User("Jack", 19));  
7.         userList.add(new User("Jim", 19));  
8.         userList.add(new User("James", 19));  
9.         userList.add(new User("Herry", 19));  
10.         userList.add(new User("Luccy", 19));  
11.         userList.add(new User("James", 18));  
12.         userList.add(new User("Herry", 20));  
13.   
14.         Collections.sort(userList, new Comparator<User>() {  
15.   
16.             public int compare(User user1, User user2) {  
17.                 int compareName = user1.getName().compareTo(user2.getName());  
18.                 if (compareName == 0) {  
19.                     return (user1.getAge() == user2.getAge() ? 0 : (user1.getAge() > user2.getAge() ? 1 : -1));  
20.                 }  
21.                 return compareName;  
22.             }  
23.         });  
24.   
25.         for (User user : userList) {  
26.             System.out.println(user.getName() + "\t\t" + user.getAge());  
27.         }  
28.     }  
29.   
30.     private static class User {  
31.   
32.         private String name;  
33.         private int    age;  
34.   
35.         public User(String name, int age){  
36.             this.name = name;  
37.             this.age = age;  
38.         }  
39.   
40.         public String getName() {  
41.             return name;  
42.         }  
43.   
44.         public int getAge() {  
45.             return age;  
46.         }  
47.     }  
48. }  

可以看出其中

Java代码  

1. Collections.sort(userList, new Comparator<User>())  

为比较的主体，并且实现了Comparator的compare方法。下面介绍下此种方法的原理

追踪Collections的

Java代码  

1. public static <T> void sort(List<T> list, Comparator<? super T> c)  

到

Java代码  

1. public static <T> void sort(T[] a, Comparator<? super T> c)  

到

Java代码  

1. private static void mergeSort(Object[] src, Object[] dest, int low, int high, int off, Comparator c)  

可以发现其中代码如下：

Java代码  

1. if (length < INSERTIONSORT_THRESHOLD) {  
2.     for (int i=low; i<high; i++)  
3.     for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)  
4.         swap(dest, j, j-1);  
5.     return;  
6. }  

 调用Comparator的compare方法

 

4、以上两种排序性能的比较

binarySort需要进行nlg(n)次的比较，最坏情况下n^2次的移动

mergeSort是不断进行二分，二分到很小部分后进行插入排序。所以会比较nlg(n)次，移动nlg(n)次。但它需要先复制一份源数据，所以会多占用一倍的空间

所以实际情况可以根据需要选择

=====================================分割线2016年1月9日13:48:19==================================================

上述排序的算法的确可以排序，但项目在那个还遇到这样的需求，就是假设含有男生的list item需要始终排在女生的前面，在内部对成绩进行从高到低或者从低到高的排序，其实也是非常容易的，就是通过第一个排序的字段始终为-1就可以实现，如下代码：

	/**
	 * 通过系统设定传递的设定字段来进行倒序
	 */
	private void sortOrderHisByAll(final int whichsort) {
		if (dataMap.isEmpty()) {
			return;
		}
		Collections.sort(dataMap, new Comparator<Map<String, Object>>() {

			@Override
			public int compare(Map<String, Object> lhs, Map<String, Object> rhs) {
				switch (whichsort) {
				case System_OrderPosition_Sort_Price_Desc:
					Double d3 = ((Double) rhs.get(LimitPrice));
					Double d4 = (Double) lhs.get(LimitPrice);
					if (d3 != null && d4 != null) {
						int flag = d3.compareTo(d4);
						if (flag == 0) {
							Double d5 = (Double) rhs.get(OriStopPrice);
							Double d6 = (Double) lhs.get(OriStopPrice);
							if (d5 != null && d6 != null) {
								return d5.compareTo(d6);
							}
						} else {
							return flag;
						}
					}
					break;
				case System_OrderPosition_Sort_Price_ASC:
					Double d31 = ((Double) rhs.get(LimitPrice));
					Double d41 = (Double) lhs.get(LimitPrice);
					if (d31 != null && d41 != null) {
						int flag = d31.compareTo(d41);
						if (flag == 0) {
							Double d5 = (Double) rhs.get(OriStopPrice);
							Double d6 = (Double) lhs.get(OriStopPrice);
							if (d5 != null && d6 != null) {
								return d6.compareTo(d5);
							}
						} else {
							<span style="color:#ff0000;">return -1;</span>
						}
					}
					break;

				default:
					break;
				}

				return 0;
			}
		});
	}