Java自带排序方法

Collections.sort(List<T> list)

该方法是升序排序，方法的内部采用了快排实现，但该方法是 稳定的。

除 Integer、Float、Double、String等Java自带类型外，list里的所有元素必须实现 Comparable接口的compareTo方法。

例子：

class Bean implements Comparable<Bean>{

      public String id;

      publicintage;

      public Bean(String id,int age){

         this.id = id;

         this.age = age;

      }

      /*

       * 先按id排序，再按age排序，这里都是从小到大排序（升序），值得注意的是，返回0与返回小于0的作用是不同的：

       * 返回大于0则希望this排在bean的后面，返回小于0则希望this排在bean前面，返回0则希望两者相对位置不变

       */

      @Override

      publicint compareTo(Bean bean) {

         int idc = this.id.compareTo(bean.id);

         if(idc==0)

            returnthis.age-bean.age;

         else

            return idc;

      }

   }

publicclass Test {

       publicstaticvoid main(String[]args){

          List<Bean> list = new ArrayList<Bean>();

          list.add(new Bean("b", 2));

          list.add(new Bean("a", 3));

          list.add(new Bean("b", 1));

          list.add(new Bean("a", 1));

          list.add(new Bean("a", 2));

          Collections.sort(list);

          for(Bean bean:list)

             System.out.println(bean.id+":"+bean.age);

       }

   }

---

Collections.sort(List<T> list,Comparator<? super T> c)

根据自定义的comparator进行排序，自定义的comparator要实现Comparator的compare方法

例子：

class Student {

   public String name;

   publicintage;

   public Student(String name,int age){

      this.name = name;

      this.age = age;

   }

}

class MyComparator implements Comparator<Student>{

   @Override

   publicint compare(Student s1, Student s2) {

      /*

       * 先比较age，如果age相等再进一步比较name，以此类推，这里采用降序排序，即从大到小。

       * 返回大于0，则希望s1排在s2的后面，返回小于0，则希望s1排在s2前面，返回0则s1、s2两者相对位置不变

       */

      if(s1.age == s2.age)

         return s2.name.compareTo(s1.name);

      else

         return s2.age-s1.age;

   }

}

publicclass Test {

    publicstaticvoid main(String[]args){

        List<Student> list = new ArrayList<Student>();

        list.add(new Student("a", 5));

        list.add(new Student("b", 4));

        list.add(new Student("b", 5));

        list.add(new Student("c", 1));

        list.add(new Student("a", 3));

        MyComparator myComparator = new MyComparator(); //自己的排序规则

        Collections.sort(list, myComparator); //根据自己定义的排序规则对List排序

        for(Student student:list)

           System.out.println(student.name+":"+student.age);

    }

}

---

Arrays.sort(T[ ] array)

与 Collections.sort(List<T> list)类似，前者对List类型排序，后者对数组排序。如果T是基本类型，如int、long、float等，内部采用的是快排实现，如果是封装类，则内部使用的归并排序。

Arrays.sort(T[ ] a, int fromIndex, int toIndex)

与上面不同在于该方法指定了只对数组的哪一部分排序

Arrays.sort(T[ ] a, Comparator<? super T> c)

与 Collections.sort(List<T> list,Comparator<? super T> c)类似，前者对List类型排序，后者对数组排序。

Arrays.sort(T[ ] a, Comparator<? super T> c, int fromIndex, int toIndex)

与上面不同在于该方法指定了只对数组的哪一部分排序

Array.sort(xxx)内部也是采用快排实现的。