Java中的数组排序

Java中的数组排序，一般是利用Arrays.sort(),这个方法是经过优化的快速排序。在Arrays种有多中形式的重载，在这里就不一一列举了。

数组排序的种类：

1.非降序排序， 非升序排序（就排序后数组元素排列的结果而言）

2.基本类型数据的排序，类类型数据的排序（就排序的对象而言）

排序示例：

int型数组的非降序排序：

 package sort;
 
 import java.util.Arrays;
 
 public class Main {
     public static void displayArray(int[] array) {
         for (int i: array) {
             System.out.print(i + " ");
         }
         System.out.println();
     }
 
     public static void main(String[] args) {
         int[] arr = new int[]{43, 84, 3, 8, 4, 7, 3, 75, 82, 748, 35};
 
         System.out.println("排序前:");
         displayArray(arr);
 
         Arrays.sort(arr);
 
         System.out.println("排序后:");
         displayArray(arr);
     }
 }

运行结果如下:

int型数组的非升序排序：

 package sort;
 
 import java.util.Arrays;
 import java.util.Comparator;
 
 public class Main {
     public static void displayArray(Integer[] array) {
         for (int i: array) {
             System.out.print(i + " ");
         }
         System.out.println();
     }
 
     public static void main(String[] args) {
         Integer[] arr = new Integer[]{43, 84, 3, 8, 4, 7, 3, 75, 82, 748, 35};
 
         System.out.println("排序前:");
         displayArray(arr);
 
         Arrays.sort(arr, new JX());
 
         System.out.println("排序后:");
         displayArray(arr);
     }
 }
 
 class JX implements Comparator<Integer> {
     @Override
     public int compare(Integer o1, Integer o2) {
         if (o1 <= o2) {
             return 1;
         }
         return -1;
     }
 }

运行结果如下：

类类型的非降序排序：

 package sort;
 
 import java.util.Arrays;
 
 public class Main {
     public static void displayArray(Student[] student) {
         for (Student s : student) {
             System.out.println(s);
         }
     }
 
     public static void main(String[] args) {
         Student[] s = new Student[5];
         s[0] = new Student("wwww", 20, 2.34);
         s[1] = new Student("kkkk", 2, 2.34);
         s[2] = new Student("pppp", 25, 3.34);
         s[3] = new Student("hhhh", 12, 4.34);
         s[4] = new Student("jjjj", 10, 5.34);
 
         System.out.println("排序前:");
         displayArray(s);
 
         Arrays.sort(s);
 
         System.out.println("排序后:");
         displayArray(s);
     }
 }
 
 /*
  * 根据年龄进行非降序排序
  */
 class Student implements Comparable<Student> {
     private String name;
     private int age;
     private double height;
 
     public Student(String name, int age, double height) {
         this.name = name;
         this.age = age;
         this.height = height;
     }
 
     @Override
     public int compareTo(Student o) {
         if (this.age <= o.age) {
             return -1;
         }
         return 1;
     }
 
     public String toString() {
         return "Name: " + name + " Age: " + age + " Height: " + height;
     }
 }

运行结果如下：

类类型的非升序排序：

 package sort;
 
 import java.util.Arrays;
 
 public class Main {
     public static void displayArray(Student[] student) {
         for (Student s : student) {
             System.out.println(s);
         }
     }
 
     public static void main(String[] args) {
         Student[] s = new Student[5];
         s[0] = new Student("wwww", 20, 2.34);
         s[1] = new Student("kkkk", 2, 2.34);
         s[2] = new Student("pppp", 25, 3.34);
         s[3] = new Student("hhhh", 12, 4.34);
         s[4] = new Student("jjjj", 10, 5.34);
 
         System.out.println("排序前:");
         displayArray(s);
 
         Arrays.sort(s);
 
         System.out.println("排序后:");
         displayArray(s);
     }
 }
 
 /*
  * 根据年龄进行非升序排序
  */
 class Student implements Comparable<Student> {
     private String name;
     private int age;
     private double height;
 
     public Student(String name, int age, double height) {
         this.name = name;
         this.age = age;
         this.height = height;
     }
 
     @Override
     public int compareTo(Student o) {
         if (this.age <= o.age) {
             return 1;
         }
         return -1;
     }
 
     public String toString() {
         return "Name: " + name + " Age: " + age + " Height: " + height;
     }
 }

运行结果如下:

根据指定属性对类类型数组排序：

 package sort;
 
 import java.util.Arrays;
 import java.util.Comparator;
 
 public class Main {
     public static void displayArray(Student[] student) {
         for (Student s : student) {
             System.out.println(s);
         }
     }
 
     public static void main(String[] args) {
         Student[] s = new Student[5];
         s[0] = new Student("wwww", 20, 2.34);
         s[1] = new Student("kkkk", 2, 2.34);
         s[2] = new Student("pppp", 25, 3.34);
         s[3] = new Student("hhhh", 12, 4.34);
         s[4] = new Student("jjjj", 10, 5.34);
         /*
         System.out.println("排序前:");
         displayArray(s);
         */
         System.out.println("按age进行非降序排序");
         Arrays.sort(s, new SortByAge());
         displayArray(s);
 
         System.out.println("按height进行非升序排序");
         Arrays.sort(s, new SortByHeight());
         displayArray(s);
     }
 }
 
 class Student {
     private String name;
     private int age;
     private double height;
 
     public Student(String name, int age, double height) {
         this.name = name;
         this.age = age;
         this.height = height;
     }
 
     public String toString() {
         return "Name: " + name + " Age: " + age + " Height: " + height;
     }
 
     public int getAge() {
         return age;
     }
 
     public double getHeight() {
         return height;
     }
 }
 
 /*
  * 按age进行非降序排序
  */
 class SortByAge implements Comparator<Student> {
     @Override
     public int compare(Student o1, Student o2) {
         if (o1.getAge() <= o2.getAge()) {
             return -1;
         }
         return 1;
     }
 }
 
 /*
  * 按height进行非升序排序
  */
 class SortByHeight implements Comparator<Student> {
     @Override
     public int compare(Student o1, Student o2) {
         if (o1.getHeight() - o2.getHeight() < 0.01) {
             return 1;
         }
         return -1;
     }
 
 }

运行结果如下：