Arrays sort 方法

---

前言

Arrays 是一个数组工具类，该类包含用于操作数组的各种方法（如排序和搜索）。 本文用于讲解排序方法

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、默认排序

	默认排序指直接传入一个数组进行排序，Arrays中默认升序，降序请看定制排序
	既然Arrays.sort()默认升序，对于数字类型数组可以按照数字大小进行排序
	那char[]和String[]是怎么排序的呢？

• char[]
  按照数字顺序排列指定的数组，根据字符的ASCII值进行排序
  sort(char[] a)

  	
  	char[] chars = {'c', 'd', 'a', 'j'}; // c	d	a	j
  		// 排序前
  		for (Object o : chars) {
  			System.out.print(o+"\t");
  		}
  		// 排序
  		Arrays.sort(chars); 
  		// 排序后
  		for (Object o : chars) {
  			System.out.print(o+"\t"); //a	c	d	j	
  		}
  

• sort(char[] a, int fromIndex, int toIndex) 按升序排列数组的指定范围。
  从fromIndex开始 ~toIndex-1 【不包括toIndex元素】

  char[] chars = {'c', 'd', 'a', 'j','z','f'};
  	// 排序前
  	for (Object o : chars) { // c	d	a	j	z	f
  		System.out.print(o+"\t");
  	}
  	Arrays.sort(chars,0,3);// 从下标0 开始，到下标3截至，只能取到下标0~2的元素
  	// 排序后
  	for (Object o : chars) { //a	c	d	j	z	f
  		System.out.print(o+"\t");
  	}
  

• sort(char[] a) 底层会调用DualPivotQuicksort.shot(char[])的排序方法

for (int i = left, j = i; i < right; j = ++i) {
                    char ai = a[i + 1];
                    while (ai < a[j]) {
                        a[j + 1] = a[j];
                        if (j-- == left) {
                            break;
                        }
                    }
                    a[j + 1] = ai;

• String[]
  字符串非基本数据类型使用sort(Object[] a) 进行排序。
  底层是根据运行类型所在类实现的Comparable接口中的compareTo()返回值排序

  String中compareTo()对比每一个字符的ASCII值进行排序

• String中compareTo()详解

// value =  private final char value[]; 是字符串底层用于字符存储。也就是字符串底层就是用char[]存值
// String的compareTo()方法
public int compareTo(String anotherString) {
        int len1 = value.length; // 当前值
        int len2 = anotherString.value.length;//传入的值
        int lim = Math.min(len1, len2);// 返回其中最小的值  (a <= b) ? a : b;
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) { //拿出每一个字符一一对比
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) { // 中间某一个字符出现了不同
                return c1 - c2; // 比出结果返回
            }
            k++;
        }
        // 比较完lim，前面的字符都一样，那就长度相减得出结果 例如 : abc -abcd
        return len1 - len2; 
    }

• 根据compareTo()返回值排序

   while (left < right) {
                int mid = (left + right) >>> 1; //无符号右移
                if (pivot.compareTo(a[mid]) < 0)
                    right = mid;
                else
                    left = mid + 1;
            }
            assert left == right;

排序演示

	String[] str = {"af", "ac", "bd", "money", "class", "dog"};
		for (Object o : str) { //af	ac	bd	money	class	dog	
			System.out.print(o+"\t");
		}
		Arrays.sort(str);
		System.out.println();
		for (Object o : str) { //ac	af	bd	class	dog	money	
			System.out.print(o+"\t");
		}

二、sort(Object[] a)

非基本数据类型创建的数组，排序都使用sort(Object[] a) 方法进行排序，比如上面讲的String方法
自己定义的类只要实现Comparable或者Comparator，也可以使用sort(Object[] a) 方法

public class ClassArr_ {
	public static void main(String[] args) {
		A[] a = new A[3];// 创建一个对象数组
		for (int i = 0; i<a.length;i++){// 遍历赋值
			a[i] = new A();
			a[i].age = i * 10;
		}
		Arrays.sort(a);// 排序
		for (int i = 0; i<a.length;i++){ //排序后 
			System.out.println(a[i].age);
		}
	}
}

class A implements Comparable<A> { //实现接口

	int age;
	@Override
	public int compareTo(A o) {
		return  o.age - age ; // 根据返回值进行排序
	}
}

• 传入引用类型数据会调用它所在类实现的Comparator接口compare()方法，底层走的binarySort()可见上面字符串

三、定制排序

 	sort(T[] a, Comparator<? super T> c)
	根据指定的比较器引发的顺序对指定的对象数组进行排序。 
	只能传入引用数据类型数组，对于基本数据类型只能包装成引用类型数据进行定制排序
	演示String根据长度进行排序

public static void main(String[] args) {
		String[] str = {"af", "ac", "bd", "money", "class", "dog","public"};
		// 排序前
		for (Object o :str) { //af	ac	bd	money	class	dog	public	
			System.out.print(o +"\t");
		}
		//	sort(T[] a, Comparator<? super T> c)
		// 匿名内部类，
			//相当实现了Comparator的类,只是没有类名而已
		Arrays.sort(str, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.length()-o2.length(); //根据返回结果进行排序
			}
		});
		// 排序后
		for (Object o :str) { // public	money	class	dog	af	ac	bd	
			System.out.print(o +"\t");
		}
	}

• sort(T[] a, Comparator<? super T> c) 详解
  不能传入基本数据了类型
  定制排序,会根据我们实现的Comparator接口排序
• 演示Integer逆序
  当我们使用了定制排序就会使用我们的实现的Comparator，不会进入Integer类所实现的Comparator接口

		Integer[] arr1 = {5, 2, 4, 1};
		// 排序前
		System.out.println(Arrays.toString(arr1));
		// 定制排序
		Arrays.sort(arr1,new Comparator<Integer>(){
			@Override
			public int compare(Integer o1, Integer o2) {
				return o2-o1;// 根据返回数值进行排序
			}
		});
		// 排序后
		System.out.println(Arrays.toString(arr1));// [5, 4, 2, 1]

• 根据compare()返回值进行排序

while (left < right) {
                int mid = (left + right) >>> 1;
                if (c.compare(pivot, a[mid]) < 0)
                    right = mid;
                else
                    left = mid + 1;
            }
            assert left == right;

总结

• . 直接传入基本数据类型，底层会走DualPivotQuicksort.shot()与之数据类型对应的排序方法

• 传入引用类型数据会调用它所在类实现的Comparator接口compare()方法，底层走的binarySort()

   自己定义的类 对象数组 需要实现 Comparator接口才能使用sort(object[]),否则报错   
  

• 定制排序,会根据我们实现的Comparator接口排序