java基础 之 排序函数（数组，集合，自定义类）

本文介绍java中有自动封装好的直接拿来就用的排序函数

集合排序

• 传入的参数只能为List，不能是其他的

  // 源码在此
  public static <T extends Comparable<? super T>> void sort(List<T> list) {
          list.sort(null);
      }
  

Collections.sort(集合对象)

• 包装类型的可以直接使用
• 传入的集合对象必须实现了Comparable接口，且重写了compareTo()方法
  

升序和降序

Collections.sort(listStudent);  // 升序
Collections.sort(listStudent,Collections.reverseOrder());  // 降序

Collections.sort(集合对象,类.比较器)

• 用于自定义类集合的排序
• 传入的结合对象实现了Comparator接口
• 重写的comparator方法，需加上静态修饰符static
• 不能使用reverseOrder来倒序排序
  

listPerson.sort(类.比较器)

• listPerson为Person类对象组成的集合名称
• 适用于自定义类数组的排序
• 传入的结合对象实现了Comparator接口
• 重写的comparator方法，需加上静态修饰符static
  

数组排序：

Arrays.sort(xx);

• 传入的对象可以是任意类型，支持包装类也支持自定义类
• 传入的对象必须实现了Comparable接口，且重写了compareTo()方法
  

Arrays.sort(xx，类.比较器);

• 适用于自定义类数组的排序
• 传入的结合对象实现了Comparator接口
• 重写的comparator方法，需加上静态修饰符static
  

代码附录

• Person类

  import java.util.Comparator;
  import java.util.Objects;
  
  public class Person{
      String name;  // 姓名
      Integer age;  // 年龄
      String phone; // 性别
  
      public String getName() {return name;}
      public void setName(String name) {this.name = name;}
      public Integer getAge() {return age;}
      public void setAge(Integer age) {this.age = age;}
      public String getPhone() {return phone;}
      public void setPhone(String sex) {this.phone = phone;}
  
      public static final Comparator<Person> COMPARATOR = new Comparator<Person>() {
          @Override
          public int compare(Person o1, Person o2) {
              int p_name= o1.getName().compareTo(o2.getName());  // 按姓名比较
              int p_age = o1.getAge().compareTo(o2.getAge());   // 按年龄
              int p_phone = o1.getPhone().compareTo(o2.getPhone());   // 按手机号比较
              if(p_name!=0){  // 先按照名称排序
                  return p_name;
              }else if(p_age!=0){  // 名称相同按照年龄
                  return p_age;
              }else { // 名称、年龄相同，按照手机号码排序
                  return p_phone;
              }
          }
      };
      // 构造方法
      public Person() {
      }
      public Person(String name, Integer age, String phone) {
          this.name = name;
          this.age = age;
          this.phone = phone;
      }
      // 重写equals方法
      @Override
      public boolean equals(Object o) {
          if (this == o) return true;
          if (!(o instanceof Person)) return false;
          Person person = (Person) o;
          return Objects.equals(getName(), person.getName()) && Objects.equals(getAge(), person.getAge()) && Objects.equals(getPhone(), person.getPhone());
      }
      // 重写hashCode
      @Override
      public int hashCode() {
          return Objects.hash(getName(), getAge(), getPhone());
      }
      // 重写toString方法，是为了打印方便
      @Override
      public String toString() {
          return "Person{" +"name='" + name + '\'' +", age=" + age +", phone='" + phone + '\'' +'}';
      }
  }
  

• Student类

  public class Student implements Comparable{
      String name;  // 姓名
      Integer age;  // 年龄
      String sno;   // 学号
      // 构造函数
      public Student(String name, Integer age, String sno) {
          this.name = name;
          this.age = age;
          this.sno = sno;
      }
      // 重写compareto方法。
      @Override
      public int compareTo(Object o) {
          if(o instanceof Student){
              Student s = (Student) o;
              int c_name= this.name.compareTo(s.name);
              int c_age = this.age.compareTo(s.age);
              int c_sno = this.sno.compareTo(s.sno);
              if(c_name!=0){  // 先按照名称排序
                  return this.name.compareTo(s.name);
              }else if(c_age!=0){  // 名称相同按照年龄排序
                  return s.age - this.age;
                  //return this.age.compareTo(s.age);
              }else { // 名称、年龄相同，按照学号排序
                  return this.sno.compareTo(s.sno);
              }
          }
          return 0;
      }
      // 方便打印显示
      @Override
      public String toString() {
          return "Student{" +"name='" + name + '\'' +", age=" + age +", sno='" + sno + '\'' +'}';
      }
  }
  

• Test类
  (最后结果自己打印看看吧)

  public class Test {
      public static void main(String[] args) {
          List<Integer> list = new ArrayList<>();
          list.add(8);
          list.add(40);
          list.add(6);
          list.add(30);
          list.add(14);
          System.out.println("排序前\n"+list);
          Collections.sort(list); // 排序
          System.out.println("排序后\n"+list);
  
          int[] arr = new int[10];
          Random random = new Random(2);
          for(int i=0;i<10;i++){
              list.add(random.nextInt(100));
              arr[i] = random.nextInt(25);
          }
          System.out.println("排序前\n"+Arrays.toString(arr));
          Arrays.sort(arr);
          System.out.println("排序后\n"+Arrays.toString(arr));
  
          List<String> listString = new ArrayList<>();
          listString.add("abc");
          listString.add("a01");
          listString.add("000");
          listString.add("bac");
          listString.add("abcdef");
          System.out.println("排序前\n"+listString);
          Collections.sort(listString); // 排序
          System.out.println("排序后\n"+listString);
  
          List<Person> listPerson = new ArrayList<>();
          listPerson.add(new Person("jackP",11,"110"));
          listPerson.add(new Person("lucyP",21,"100"));
          listPerson.add(new Person("milkP",11,"120"));
          listPerson.add(new Person("adaP",45,"999"));
          listPerson.add(new Person("jackP",11,"109"));
          System.out.println("排序前\n"+listPerson);
          //Collections.sort(listPerson,Person.COMPARATOR);   // 两个排序是一样的效果
          listPerson.sort(Person.COMPARATOR);     // 使用这个排序必须要实现comparator的匿名函数
          System.out.println("排序后\n"+listPerson);
  
          Person[] persons = new Person[5];
          persons[0] = new Person("jackS",11,"110");
          persons[1] = new Person("lucyS",21,"100");
          persons[2] = new Person("milkS",11,"120");
          persons[3] = new Person("adaS",45,"999");
          persons[4] = new Person("jackS",21,"110");
          System.out.println("排序前\n"+Arrays.toString(persons));
          Arrays.sort(persons,Person.COMPARATOR);  // 排序
          System.out.println("排序后\n"+Arrays.toString(persons));
  
          List<Student> listStudent = new ArrayList<>();
          listStudent.add(new Student("jackS",11,"110"));
          listStudent.add(new Student("lucyS",21,"100"));
          listStudent.add(new Student("milkS",11,"120"));
          listStudent.add(new Student("adaS",45,"999"));
          listStudent.add(new Student("jackS",21,"110"));
          listStudent.add(new Student("lucyS",21,"100"));
          System.out.println("排序前\n"+listStudent);
          Collections.sort(listStudent);
          System.out.println("排序后\n"+listStudent);
  
  
          Student[] students = new Student[5];
          students[0] = new Student("jackS",11,"110");
          students[1] = new Student("lucyS",21,"100");
          students[2] = new Student("milkS",11,"120");
          students[3] = new Student("adaS",45,"999");
          students[4] = new Student("jackS",21,"110");
          System.out.println("排序前\n"+Arrays.toString(students));
          Arrays.sort(students);
          System.out.println("排序后\n"+Arrays.toString(students));
      }
  }