JAVA中Collections工具类sort()排序方法

本问介绍了Collections工具类两种sort()方法，具体如下：

一、Collections工具类两种sort()方法

格式一： public static <T extends Comparable<? super T>> void sort(List<T> list)

说明：该方法中的泛型<T>都是Comparable接口的子类，即只有是Comparable接口子类类型的数据，才能进行比较排序。如果其他类型的数据要进行比较排序，必须继承Comparable接口并

覆写equals()和compareTo()方法。其中如String类、Integer类都是Comparable接口子类，可以进行排序，而基本类型不能进行sort排序。比较项目在类内指定

格式二：public static <T> void sort(List<T> list, Comparator<? super T> c)

说明：该方法中指定比较方式Comparator<? super T> c，即c必须实现Comparator<? super T>接口，覆写compareTo()方法指定比较项目。比较项目在类外指定，比较灵活

二、示例

示例中获取字符串和数字的公用方法：

/**
  * 生成随机 不重复的字符串 : number 生成字符串个数
  */
 public static List<String> generateString(int number) {
   List<String> listString = new ArrayList<>(); // 用于存放返回值
   List<Integer> length = null; // 字符串长度
   StringBuffer sb = new StringBuffer(); // 中间变量
   int control = 0; // 控制个数
   String[] chars = new String[] { "a", "b", "c", "d", "e", "f", "g", "h",
       "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
       "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
       "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H",
       "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
       "U", "V", "W", "X", "Y", "Z" };
   while (true) {
     // 控制结束
     if ( control==number ) {
       break;
     }
     // 生成随机数，生成36位的2aaab761-4341-4968-aceb-3861ee3824b2 UUID类型数据
     String uuid = UUID.randomUUID().toString().replace("-", "");
     sb.setLength(0);
     // 获得随机字符串长度，长度不为0
     do {
       length = getDiffNo(1, 11);
     } while ( length.get(0)==0 );
     // 拼凑字符串
     for (int i=0; i<length.get(0); i++) {
       String str = uuid.substring(i*3, (i*3+3));
       //将str字符串转换为16进制，获得其值
       int x = Integer.parseInt(str, 16);
       //取余：x ％ 0x3E--0x3E = 3*16 + 14 = 62, 其中chars有62个字符
       sb.append(chars[x ％ 0x3E]);
     }
     listString.add(sb.toString());
     control++;
   }
   return listString;
 }

/**
  * 生成随机不重复的数字 :n生成个数 max生成范围
  */
 public static List<Integer> getDiffNo(int n, int max) {
   // 生成 [0-n] 个不重复的随机数
   // list 用来保存这些随机数
   List<Integer> list = new ArrayList<>();
   Random random = new Random();
   Integer k;
   for (int i=0; i<n; i++) {
     do {
       k = random.nextInt(max);
     } while (list.contains(k));
     list.add(k);
   }
   return list;
 }

1、对Integer泛型的List进行排序

/**
  * 1.通过Collections.sort()方法，对Integer泛型的List进行排序；
  * 创建一个Integer泛型的List，插入十个100以内的不重复随机整数， 调用Collections.sort()方法对其进行排序
  * 2.排序规则：先数字后字母，数字0-9，字母A-Z a-z的顺序
  */
 public void listIntegerSort() {
   // 插入十个100以内的不重复随机整数
   List<Integer> integerList = getDiffNo(10, 100);
   System.out.println("-------------排序前--------------");
   for (Integer integer : integerList) {
     System.out.println("元素：" + integer);
   }
   Collections.sort(integerList);
   System.out.println("----------------排序后-------------------");
   for (Integer integer : integerList) {
     System.out.println("元素：" + integer);
   }
 }

2、对String泛型的List进行排序

/**
  * 1.对String泛型的List进行排序； 创建String泛型的List，添加乱序的String元素，
  * 调用sort方法，再次输出排序后的顺序
  */
 public void listStringSort() {
   List<String> stringList = new ArrayList<String>();
   stringList.add("eipJlcx");
   stringList.add("WvQRufC");
   stringList.add("J");
   stringList.add("HdaU2G");
   stringList.add("M0WswHD3");
   System.out.println("------------排序前-------------");
   for (String string : stringList) {
     System.out.println("元素：" + string);
   }
   Collections.sort(stringList);
   System.out.println("--------------排序后---------------");
   for (String string : stringList) {
     System.out.println("元素：" + string);
   }
 }

/**
  * 对String泛型的List进行排序，要求随机生成10个的不重复字符串，字符串的长度在10以内
  */
 public void listStringRandomSort() {
   // 生成随机字符串
   List<String> listString = generateString(10);
   System.out.println("--------------排序前---------------");
   for (String integer : listString) {
     System.out.println("元素：" + integer);
   }
   // 排序
   Collections.sort(listString);
   System.out.println("----------------排序后------------------");
   for (String integer : listString) {
     System.out.println("元素：" + integer);
   }
 }

3、对其他类型泛型的List进行排序

Course类实现

/**
* 课程类
* @author Administrator
*
*/
public class Course {
 public String id;
 public String name;
 public Course(String id, String name) {
   this.id = id ;
   this.name = name;
 }
 public Course() {
 }

@Override
 public int hashCode() {
   final int prime = 31;
   int result = 1;
   result = prime * result + ((name == null) ? 0 : name.hashCode());
   return result;
 }

@Override
 public boolean equals(Object obj) {
   if (this == obj)
     return true;
   if (obj == null)
     return false;
   if (!(obj instanceof Course))
     return false;
   Course other = (Course) obj;
   if (name == null) {
     if (other.name != null)
       return false;
   } else if (!name.equals(other.name))
     return false;
   return true;
 }
}

Student类实现Comparable接口，类内设置比较项

import java.util.HashSet;
import java.util.Set;

/**
* 学生类
* @author Administrator
*
*/
public class Student implements Comparable<Student> {
 public String id;
 public String name;
 public Set<Course> courses;

public Student(String id, String name) {
   this.id = id;
   this.name = name;
   this.courses = new HashSet<Course>();
 }

@Override
 public int hashCode() {
   final int prime = 31;
   int result = 1;
   result = prime * result + ((name == null) ? 0 : name.hashCode());
   return result;
 }

@Override
 public boolean equals(Object obj) {
   if (this == obj)
     return true;
   if (obj == null)
     return false;
   if (!(obj instanceof Student))
     return false;
   Student other = (Student) obj;
   if (name == null) {
     if (other.name != null)
       return false;
   } else if (!name.equals(other.name))
     return false;
   return true;
 }

@Override
 public int compareTo(Student o) { // 设置ID为比较项
   // TODO Auto-generated method stub
   return this.id.compareTo(o.id);
 }
}

实现Comparator接口，类外设置比较项

import java.util.Comparator;
public class StudentComparator implements Comparator<Student> {

@Override
 public int compare(Student o1, Student o2) {
   // TODO Auto-generated method stub
   return o1.name.compareTo(o2.name);
 }
}

比较Student类

/**
  * 对其他类型泛型的List进行排序，以Student为例。
  */
 public void listComparatorSort() {
   List<Student> studentList = new ArrayList<Student>();
   List<Integer> list = getDiffNo(4, 1000);

studentList.add(new Student(list.get(0) + "", "Mike"));
   studentList.add(new Student(list.get(1) + "", "Angela"));
   studentList.add(new Student(list.get(2) + "", "Lucy"));
   studentList.add(new Student(1000 + "", "Beyonce"));
   System.out.println("--------------排序前---------------");
   for (Student student : studentList) {
     System.out.println("学生：" + student.id + ":" + student.name);
   }
   // 实现Comparator<T>接口，设置ID比较方式
   Collections.sort(studentList);
   System.out.println("----------------按照ID排序后------------------");
   for (Student student : studentList) {
     System.out.println("学生：" + student.id + ":" + student.name);
   }

// 实现Comparator<T>接口，设置特定比较方式，以name比较排序
   Collections.sort(studentList, new StudentComparator());
   System.out.println("----------------按照姓名排序后-----------------");
   for (Student student : studentList) {
     System.out.println("学生：" + student.id + ":" + student.name);
   }
 }