Collections sort() 合并排序

Collections 的sort方法使用的是合并排序算法，使用时注意list中的元素需要实现Comparable接口。

 这里有个简单的例子：

  1 public int compareTo(Object obj) {

 2           if  (obj  instanceof  TestObject) {
 3              TestObject to  =  (TestObject) obj;
 4               if  ( this .getLength()  >  to.getLength()) {
 5                   return   1 ;
 6              }  else   if  ( this .getLength()  ==  to.getLength()) {
 7                   return   0 ;
 8              }  else  {
 9                   return   - 1 ;
10              }
11          }  else  {
12               throw   new  ClassCastException();
13          }
14      }

 

 

下面是源码： 

 1       /**
 2       * Sorts the specified list into ascending order, according to the
 3       * <i>natural ordering</i> of its elements.   All elements in the list must
 4       * implement the <tt>Comparable</tt> interface.   Furthermore, all elements
 5       * in the list must be <i>mutually comparable</i> (that is,
 6       * <tt>e1.compareTo(e2)</tt> must not throw a <tt>ClassCastException</tt>
 7       * for any elements <tt>e1</tt> and <tt>e2</tt> in the list).<p>
 8       *
 9       * This sort is guaranteed to be <i>stable</i>:  equal elements will
10       * not be reordered as a result of the sort.<p>
11       *
12       * The specified list must be modifiable, but need not be resizable.<p>
13       *
14       * The sorting algorithm is a modified mergesort (in which the merge is
15       * omitted if the highest element in the low sublist is less than the
16       * lowest element in the high sublist).  This algorithm offers guaranteed
17       * n log(n) performance.
18       *
19       * This implementation dumps the specified list into an array, sorts
20       * the array, and iterates over the list resetting each element
21       * from the corresponding position in the array.  This avoids the
22       * n² log(n) performance that would result from attempting
23       * to sort a linked list in place.
24       *
25       *  @param   list the list to be sorted.
26       *  @throws  ClassCastException if the list contains elements that are not
27       *           <i>mutually comparable</i> (for example, strings and integers).
28       *  @throws  UnsupportedOperationException if the specified list's
29       *           list-iterator does not support the <tt>set</tt> operation.
30       *  @see  Comparable
31        */
32       public   static   < T  extends  Comparable <?   super  T >>   void  sort(List < T >  list) {
33      Object[] a  =  list.toArray();
34      Arrays.sort(a);
35      ListIterator < T >  i  =  list.listIterator();
36       for  ( int  j = 0 ; j < a.length; j ++ ) {
37          i.next();
38          i.set((T)a[j]);
39      }
40      }