手写快排和Arrays.sort()比较

代码如下

public static void main(String[] args){
        Long startTime = System.nanoTime();
        int[] nums=new int[]{2,3,6,7,5,4,1};
        DoubleSort.quickSort2(nums,0,nums.length-1);
        Long endTime = System.nanoTime();
        System.out.println("quickSort:"+(endTime-startTime));

        Long startTime1 = System.nanoTime();
        int[] nums1=new int[]{2,3,6,7,5,4,1};
        Arrays.sort(nums1);
        Long endTime1 = System.nanoTime();
        System.out.println("Arrays:"+(endTime1-startTime1));
    }

快排类

static void quickSort2(int[] nums,int i,int j){
        int indexI=i,indexJ=j;
        if(i>=j){
            return;
        }
        int key=nums[i];
        while(i<j){
            while(i<j&&nums[j]>=key){
                j--;
            }
            nums[i]=nums[j];
            while(i<j&&nums[i]<=key){
                i++;
            }
            nums[j]=nums[i];
        }
        nums[i]=key;
        quickSort2(nums,indexI,i-1);
        quickSort2(nums,j+1,indexJ);
    }

比较结果如下
可以看出Arrays类是比快排要快的

Arrays.sort的几种用法

• Arrays.sort(int[] nums)
• Arrays.sort(int[] nums, int fromIndex, int toIndex) 左闭右开
• public static void sort(T[] a,int fromIndex, int toIndex, Comparator<? super T> c)

 1 import java.util.Arrays;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5         
 6         int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
 7         Arrays.sort(a);
 8         for(int i = 0; i < a.length; i ++) {
 9             System.out.print(a[i] + " ");
10         }
11     }
12 
13 }

 1 import java.util.Arrays;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5         
 6         int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
 7         Arrays.sort(a, 0, 3);
 8         for(int i = 0; i < a.length; i ++) {
 9             System.out.print(a[i] + " ");
10         }
11     }
12 
13 }

 1 package test;
 2 
 3 import java.util.Arrays;
 4 import java.util.Comparator;
 5 
 6 public class Main {
 7     public static void main(String[] args) {
 8         //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
 9         //而要使用它们对应的类
10         Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
11         //定义一个自定义类MyComparator的对象
12         Comparator cmp = new MyComparator();
13         Arrays.sort(a, cmp);
14         for(int i = 0; i < a.length; i ++) {
15             System.out.print(a[i] + " ");
16         }
17     }
18 }
19 //Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
20 //而不是extends Comparator
21 class MyComparator implements Comparator<Integer>{
22     @Override
23     public int compare(Integer o1, Integer o2) {
24         //如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值，
25         //这样颠倒一下，就可以实现反向排序了
26         if(o1 < o2) { 
27             return 1;
28         }else if(o1 > o2) {
29             return -1;
30         }else {
31             return 0;
32         }
33     }
34     
35 }

• 降序排序

	public void CollectionsSort() {
		Arrays.sort(arr,Collections.reverseOrder());
		for(Integer x:arr)
			System.out.print(x+" ");
	}

对基本数据类型数组的排序

• 1>数字排序：

int[] intArray = new int[]{1,56,-5,33}; 
Arrays.sort(intArray); 
System.out.println(Arrays.toString(intArray)); 

• 2>字符串排序(先大写后小写)：

String[] strArray = new String[]{"Z", "a", "D"}; 
Arrays.sort(strArray); 
System.out.println(Arrays.toString(strArray)); 

• 3>字符串字母表排序(忽略大小写)

Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); 

• 4>反向排序

Arrays.sort(strArray, Collections.reverseOrder()); 

原理

    java中Arrays.sort使用了两种排序方法，快速排序和优化的合并排序。

    快速排序主要是对哪些基本类型数据（int,short,long等）排序， 而合并排序用于对对象类型进行排序。
    使用不同类型的排序算法主要是由于快速排序是不稳定的，而合并排序是稳定的。这里的稳定是指比较相等的数据在排序之后仍然按照排序之前的前后顺序排列。对于基本数据类型，稳定性没有意义，而对于对象类型，稳定性是比较重要的，因为对象相等的判断可能只是判断关键属性，最好保持相等对象的非关键属性的顺序与排序前一直；另外一个原因是由于合并排序相对而言比较次数比快速排序少，移动（对象引用的移动）次数比快速排序多，而对于对象来说，比较一般比移动耗时。

    补充一点合并排序的时间复杂度是n*logn, 快速排序的平均时间复杂度也是n*logn，但是合并排序的需要额外的n个引用的空间 ......