JAVA里sort()方法的使用与原理解析_java sort()

Arrays.sort和Collections.sort实现原理解析

1、使用

• 排序

sort()是Java中用来排序的一个方法,在我们专心学习各种经典排序算法的时候,其实在代码中一个sort()就可以解决,并且时间复杂度和空间复杂度相对都不会过高。
其实sort()不光可以对数组进行排序,基本数据类型的数组都可以,并且可以实现对对象数组的排序.接下来介绍一下用法.

1. 基本数据类型

(1)数字类型:

int[] a = {1, 3, 4, 67, 78, 9, 90, 6, 3, 2};
Arrays.sort(a);//对数组进行排序
System.out.println(Arrays.toString(a));//遍历并输出整个数组
1
2
3

数字类型很简单了,就是从小到大排序(浮点类型与整形同理),输出结果如下:

[1, 2, 3, 3, 4, 6, 9, 67, 78, 90]

(2)字符串类型:

String[] strArray = new String[]{"Zs","ZA", "aa", "Az","D","w","A","z"};
Arrays.sort(strArray);
System.out.println(Arrays.toString(strArray));
1
2
3

运行结果如下:

[A, D, Hello, Hello kity, hello, hello kity, w, z]

对于字符串类型的数组，sort() 则是将字符串的开头字母进行排序,排列顺序为：大写在小写前,从A~Z依次往下排，若第一位相同则比较第二位，规则相同，若第三位也相同，依次往下比较。

还有一种按照字母表排序,忽略大小写的方式

String[] strArray = new String[]{"hello","Hello", "Hello kity", "hello kity","D","w","A","z"};
Arrays.sort(strArray ,String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(strArray));
1
2
3

运行结果如下:

[A, D, hello, Hello, Hello kity, hello kity, w, z] (和上面的不同仔细看!)

2. 对象数组

对象怎么进行排序呢?这时候就需要我们自己制定排序规则了(比如说,给student对象排序,是将学号id进行排序),但是如果是每个不同的类型的对象,我们都需要去分析数据,自己手动敲规则的话,过于麻烦.所以我们用到Comparable或者Comparator接口.

拿Comparator为例,里面有个方法

int compare(T o1,T o2);

用法举例说明:

public class Student  {
    private int id;
    private int age;
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", age=" + age +
                '}';
    }
    public Student(int id, int age){
        this.id = id;
        this.age = age;
    }
//通过id排序
    public static class SortById implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return o1.id - o2.id;
        }
    }
//通过age排序
    public static class SortByAge implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return o1.age - o2.age;
        }
    }
    public static void main(String[] args) {
        Student s1 = new Student(11110,13);
        Student s2 = new Student(11112,12);
        Student[] ss = {s1, s2};
        Arrays.sort(ss,new SortById());
        for (Student s : ss) {
            System.out.print(s);
        }
        System.out.println();
        Arrays.sort(ss,new SortByAge());
        for (Student s : ss) {
            System.out.print(s);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

运行结果如下:

Conparable原理类似,在这里不做介绍.

2、原理

为什么sort()都可以排序呢?而且时间和空间复杂度都还比较优良，有没有人想过sort()里面是怎么实现的呢？

事实上Collections.sort方法底层就是调用的Arrays.sort方法
跟踪下源代码吧，首先我们写个demo

public static void main(String[] args) {
	List<String> strings = Arrays.asList("6", "1", "3", "1","2");
	
	Collections.sort(strings);//sort方法在这里
	
	for (String string : strings) {
	    System.out.println(string);
	}
}
1
2
3
4
5
6
7
8
9

简单得不能再简单的方法了，让我们一步步跟踪

OK，往下面看，发现collections.sort方法调用的list.sort

然后跟踪一下，list里面有个sort方法，但是list是一个接口，肯定是调用子类里面的实现，这里我们demo使用的是一个Arrays.asList方法，所以事实上我们的子类就是arraylist了。OK，看arraylist里面sort实现，选择第一个，为什么不选择第二个呢？（在创建List对象的时候，使用了Arrays.asList()方法，从其实现源码可以看出，该方法创建的ArrayList对象其实是Arrays类内部自带的，所以在debug跟踪源代码的时候，进入的是Arrays内部的ArrayList对象。简单说就是用Arrays.sort创建的ArrayList对象）

OK，发现里面调用的Arrays.sort(a, c); a是list,c是一个比较器，我们来看一下这个方法

我们没有写比较器，所以用的第二项，LegacyMergeSort.userRequested这个bool值是什么呢？
跟踪这个值，我们发现有这样的一段定义：

  > Old merge sort implementation can be selected (for
  >  compatibility with broken comparators) using a system property.
  >  Cannot be a static boolean in the enclosing class due to
  >  circular dependencies. To be removed in a future release.

  //反正是一种老的归并排序，不用管了现在默认是关的

1
2
3
4
5
6
7

OK，我们走的是sort(a)这个方法，接着进入这个

接着看我们重要的sort方法

static void sort(Object[] a, int lo, int hi, Object[] work, int workBase, int workLen) {
	assert a != null && lo >= 0 && lo <= hi && hi <= a.length;

    int nRemaining  = hi - lo;
    if (nRemaining < 2)
        return;  // array的大小为0或者1就不用排了

    // 当数组大小小于MIN_MERGE(32)的时候，就用一个"mini-TimSort"的方法排序，jdk1.7新加
    if (nRemaining < MIN_MERGE) {
       //这个方法比较有意思，其实就是将我们最长的递减序列，找出来，然后倒过来
        int initRunLen = countRunAndMakeAscending(a, lo, hi);
        //长度小于32的时候，是使用binarySort的
        binarySort(a, lo, hi, lo + initRunLen);
        return;
    }
   //先扫描一次array，找到已经排好的序列，然后再用刚才的mini-TimSort，然后合并，这就是TimSort的核心思想
    ComparableTimSort ts = new ComparableTimSort(a, work, workBase, workLen);
    int minRun = minRunLength(nRemaining);
    do {
        // Identify next run
        int runLen = countRunAndMakeAscending(a, lo, hi);

        // If run is short, extend to min(minRun, nRemaining)
        if (runLen < minRun) {
            int force = nRemaining <= minRun ? nRemaining : minRun;
            binarySort(a, lo, lo + force, lo + runLen);
            runLen = force;
        }

        // Push run onto pending-run stack, and maybe merge
        ts.pushRun(lo, runLen);
        ts.mergeCollapse();

        // Advance to find next run
        lo += runLen;
        nRemaining -= runLen;
    } while (nRemaining != 0);

    // Merge all remaining runs to complete sort
    assert lo == hi;
    ts.mergeForceCollapse();
    assert ts.stackSize == 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

回到5，我们可以看到当我们写了比较器的时候就调用了TimSort.sort方法，源码如下

static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                                  T[] work, int workBase, int workLen) {
	assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
	
	int nRemaining  = hi - lo;
	if (nRemaining < 2)
	    return;  // Arrays of size 0 and 1 are always sorted
	
	// If array is small, do a "mini-TimSort" with no merges
	if (nRemaining < MIN_MERGE) {
	    int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
	    binarySort(a, lo, hi, lo + initRunLen, c);
	    return;
	}
	
	/**
	 * March over the array once, left to right, finding natural runs,
	 * extending short natural runs to minRun elements, and merging runs
	 * to maintain stack invariant.
	 */
	TimSort<T> ts = new TimSort<>(a, c, work, workBase, workLen);
	int minRun = minRunLength(nRemaining);
	do {
	   // Identify next run
	   int runLen = countRunAndMakeAscending(a, lo, hi, c);
	
	   // If run is short, extend to min(minRun, nRemaining)
	   if (runLen < minRun) {
	       int force = nRemaining <= minRun ? nRemaining : minRun;
	       binarySort(a, lo, lo + force, lo + runLen, c);
	       runLen = force;
	   }
	
	   // Push run onto pending-run stack, and maybe merge
	   ts.pushRun(lo, runLen);
	   ts.mergeCollapse();
	
	   // Advance to find next run
	   lo += runLen;
	   nRemaining -= runLen;
	} while (nRemaining != 0);
	
	// Merge all remaining runs to complete sort
	assert lo == hi;
	ts.mergeForceCollapse();
	assert ts.stackSize == 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

和上面的sort方法是一样的，其实也就是TimSort的源代码

3、总结

不论是Collections.sort方法或者是Arrays.sort方法，底层实现都是TimSort实现的，这是jdk1.7新增的，以前是归并排序。TimSort算法就是找到已经排好序数据的子序列，然后对剩余部分排序，然后合并起来。

---

事实上Collections.sort方法底层就是调用的Arrays.sort方法，而Arrays.sort使用了两种排序方法，快速排序和优化的归并排序。

快速排序(quick)主要是对那些基本类型数据（int, short, long等）排序， 而归并排序(merge)用于对Object类型进行排序。
使用不同类型的排序算法主要是由于快速排序是不稳定的，而归并排序是稳定的。这里的稳定是指比较相等的数据在排序之后仍然按照排序之前的前后顺序排列。对于基本数据类型，稳定性没有意义，而对于Object类型，稳定性是比较重要的，因为对象相等的判断可能只是判断关键属性，最好保持相等对象的非关键属性的顺序与排序前一致；另外一个原因是由于归并排序相对而言比较次数比快速排序少，移动（对象引用的移动）次数比快速排序多，而对于对象来说，比较一般比移动耗时。
此外，对大数组排序。快速排序的sort()采用递归实现，数组规模太大时会发生堆栈溢出，而归并排序sort()采用非递归实现，不存在此问题。

sort()是根据需要排序的数组的长度进行区分的:

首先先判断需要排序的数据量是否大于60。
小于60：使用插入排序，插入排序是稳定的
大于60的数据量会根据数据类型选择排序方式：
基本类型：使用快速排序。「因为基本类型不需要考虑稳定性」
Object类型：使用归并排序「因为归并排序具有稳定性」

注意：不管是快速排序还是归并排序。在二分的时候小于60的数据量依旧会使用插入排序
1

P.s. 稳定：比较相等的数据，在排序后仍然保持之前的顺序

---

原文链接：https://blog.csdn.net/huanghanqian/article/details/79637322
原文链接：https://blog.csdn.net/u011410529/article/details/56668545
原文链接：https://blog.csdn.net/qq_39411607/article/details/80224103