java array List排序

在java 中 对list排序用 

      //Collections.sort( userlist, comparator);

             Collections.sort (userlist);// User 类需要继承实现Comparable

对数组排序可直接用：

Arrays. sort(intArray );

package com.czy.sort;

public class User implements Comparable<User> {

      String name;

      String age;

       public User(String name, String age) {

             this. name = name;

             this. age = age;

      }

       public String getAge() {

             return age ;

      }

       public void setAge(String age) {

             this. age = age;

      }

       public String getName() {

             return name ;

      }

       public void setName(String name) {

             this. name = name;

      }

       @Override

       public int compareTo(User user) {

             int flag = this.getAge().compareTo(user.getAge());

             if (flag == 0) {

                   return this .getName().compareTo(user.getName());

            } else {

                   return flag;

            }

      }

}

package com.czy.sort;

import java.util.Comparator;

public class ComparatorUser implements Comparator{

       public int compare(Object arg0, Object arg1) {

             User user0 = (User ) arg0;

             User user1 = (User ) arg1;

             // 首先比较年龄，如果年龄相同，则比较名字

             int flag = user0.getAge().compareTo(user1.getAge());

             if (flag == 0) {

                   returnuser0.getName().compareTo(user1.getName());

            } else {

                   return flag;

            }

      }

}

package com.czy.sort;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class SortTest {

       public static void main(String[] args) {

             List userlist = new ArrayList();

             userlist.add( new User( "dd", "4" ));

             userlist.add( new User( "aa", "1" ));

             userlist.add( new User( "ee", "5" ));

             userlist.add( new User( "bb", "2" ));

             userlist.add( new User( "ff", "5" ));

             userlist.add( new User( "cc", "3" ));

             userlist.add( new User( "gg", "6" ));

             //ComparatorUser comparator = new ComparatorUser();

             //Collections.sort( userlist, comparator);

             Collections.sort (userlist);// User 类需要继承实现Comparable

             for ( int i = 0; i < userlist.size(); i++) {

                  User user_temp = (User) userlist.get(i);

                  System. out.println(user_temp.getAge() + "," + user_temp.getName());

            }

      }

}

在java 内部 还是将list 转换成array，然后再对数组进行排序

      Object[] a = list.toArray();

      Arrays. sort(a);

      ListIterator<T> i = list.listIterator();

       for ( int j=0; j<a. length; j++) {

          i.next();

          i.set((T)a[j]);

      }

再看 sort：

     public static void sort(Object[] a) {

        Object[] aux = (Object[])a.clone();

        mergeSort(aux, a, 0, a.length , 0);

    }

再看 mergeSort（归并排序）：

     private static void mergeSort (Object[] src,

                          Object[] dest,

                          int low,

                          int high,

                          int off) {

       int length = high - low;

       // Insertion sort on smallest arrays

        if (length < INSERTIONSORT_THRESHOLD ) {

            for ( int i=low; i<high; i++)

                for ( int j=i; j>low &&

                   ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)

                    swap(dest, j, j-1);

            return ;

        }

        // Recursively sort halves of dest into src

        int destLow  = low;

        int destHigh = high;

        low  += off;

        high += off;

        int mid = (low + high) >>> 1;

        mergeSort(dest, src, low, mid, -off);

        mergeSort(dest, src, mid, high, -off);

        // If list is already sorted, just copy from src to dest.  This is an

        // optimization that results in faster sorts for nearly ordered lists.

        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {

            System. arraycopy(src, low, dest, destLow, length);

            return ;

        }

        // Merge sorted halves (now in src) into dest

        for( int i = destLow, p = low, q = mid; i < destHigh; i++) {

            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)

                dest[i] = src[p++];

            else

                dest[i] = src[q++];

        }

    }