Java的Arrays.sort()良心总结

C语言的stilib.h头文件中有qsort()，C++的STL库中有sort(),这些封装好的排序函数让我们避免了比赛手写排序，给我们解题带来了的便利。在Java的Arrays类中也封装好了类似的方法sort()。
基本格式：

Arrays.sort(num);
Arrays.sort(num,c);
Arrays.sort(num,0,n);
Arrays.sort(num,0,n,c);

1.Arrays.sort(num);

这种格式的调用只能适用于数组在创建时就初始化的情况，默认将数组升序排序。

import java.util.*;
public class Main {
	public static void main(String[] args) {
		int num[]=new int[] {1,9,2,6,0,8,1,7};
		
		Arrays.sort(num);
		
		for(int i=0;i<num.length;i++) {
			System.out.print(num[i]+" ");
		}
	}
}

运行结果：

0 1 1 2 6 7 8 9

2.Arrays.sort(num,c);

但是如果只进行升序排序则不能满足我们的比赛需求。如需降序排序，这种格式就派上用场了。类似C++的sort()函数的参数cmp函数，这里需要传入实现了Comparator接口的类的对象c。

这种重载形式的方法原型如下：

public static void sort(T[] a,Comparator<? super T> c)

从函数原型中可以看出，我们的num数组的类型必须是基本类型（如int、char、double……）对应的类（如Integer、Character、Double……）的对象（而且数组必须在创建时就初始化）

对于实现了Comparator接口的类的对象c的写法，如果只是对基本类型对应的类对象的排序，我个人比较推荐匿名内部类的写法。

import java.util.*;
public class P1478 {
	public static void main(String[] args) {
		Integer num[]=new Integer[] {1,9,2,6,0,8,1,7};//初始化Integer对象的数组
		
		Arrays.sort(num,new Comparator<Integer>() {
			public int compare(Integer a,Integer b) {
				return b-a;
			}
		});
		
		for(int i=0;i<num.length;i++) {
			System.out.print(num[i]+" ");
		}
	}
}

运行结果：

9 8 7 6 2 1 1 0

3.Arrays.sort(num, fromIndex, toIndex);

和前面的格式相比，这种更为通用。它能运用在数组在运行过程初始化的情况，给下标在区间[fromIndex, toIndex)的元素排序。

import java.util.*;
public class Main {
	static final int maxn=100005;
	static int n;
	static int num[]=new int[maxn];
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		n=cin.nextInt();
		for(int i=0;i<n;i++) {
			num[i]=cin.nextInt();
		}
		
		Arrays.sort(num, 0,n);
		
		for(int i=0;i<n;i++) {
			System.out.println(num[i]);
		}
	}
}

输入：

8
1 9 2 6 0 8 1 7

运行结果：

0 1 1 2 6 7 8 9

4.Arrays.sort(num,0,n,c);

• 这种格式只是在第2种的基础上加上了第3种，于是他们的特点也是相叠加的，这里就不多加赘述了。
• 通常这种格式会被运用在我们C++中需要用上结构体排序的题目上，因为对于自定义的数据类型，排序时一定要写cmp函数。Java中没有结构体，所以我们只能类似写结构体那样定义类。（注意：如果定义的类写在主类里面，就要加上static关键字，写在外面则不用）
• 对于实现了Comparator接口的类的对象c的写法，如果只要排序一次，我们还是可以写匿名内部类。如果是多次排序的话，我们可以让定义的类实现Comparator接口，写把compare方法写在定义的类里面。（最后例题的代码就是这种写法）
• 要输入定义的类对象的数据时，要先初始化该对象（例如下面的：num[i]=new People();）

import java.util.*;
public class Main {
	static class People{
		String name;
		int age;
	}
	static final int maxn=100005;
	static int n;
	static People num[]=new People[maxn];
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		n=cin.nextInt();
		for(int i=0;i<n;i++) {
			num[i]=new People(); //要记得先初始化
			num[i].name=cin.next();
			num[i].age=cin.nextInt();
		}
		
		Arrays.sort(num, 0, n,new Comparator<People>() {
			public int compare(People a, People b) {
				//return a.age-b.age;            //按年龄升序排序
				return a.name.compareTo(b.name); //按名字升序排序
			}
		});
		
		for(int i=0;i<n;i++) {
			System.out.println(num[i].name+" "+num[i].age);
		}
	}
}

实战演练

不管怎么样，刚学的东西还是要练练的。下面是来自洛谷的一道运用到结构体排序的题目，虽然比较简单，但是也算是一种实战吧。
传送门

题目描述

又是一年秋季时，陶陶家的苹果树结了n个果子。陶陶又跑去摘苹果，这次她有一个a公分的椅子。当他手够不着时，他会站到椅子上再试试。

这次与NOIp2005普及组第一题不同的是：陶陶之前搬凳子，力气只剩下s了。当然，每次摘苹果时都要用一定的力气。陶陶想知道在s<0之前最多能摘到多少个苹果。

现在已知n个苹果到达地上的高度xi，椅子的高度a，陶陶手伸直的最大长度b，陶陶所剩的力气s，陶陶摘一个苹果需要的力气yi，求陶陶最多能摘到多少个苹果。

输入格式：

第1行：两个数 苹果数n，力气s。

第2行：两个数 椅子的高度a，陶陶手伸直的最大长度b。

第3行~第3+n-1行：每行两个数 苹果高度xi，摘这个苹果需要的力气yi。

输出格式：

只有一个整数，表示陶陶最多能摘到的苹果数。

输入样例#1：

8 15
20 130
120 3
150 2
110 7
180 1
50 8
200 0
140 3
120 2

输出样例#1：

4

说明

所有数据：n<=5000 a<=50 b<=200 s<=1000

分析

简单的贪心法题目，只要把苹果按按消耗的体力升序排序，然后只要能够得着就去摘（计数器加一），当体力不足以摘苹果或者遍历了所有苹果之后结束，最后输出。
//贪心法的证明？我不会证明QAQ

代码如下

import java.util.*;
public class Main {
	static class Apple implements Comparator<Apple>{  //实现Comparator接口
		int cost,height;
		public int compare(Apple a,Apple b) {
			return a.cost-b.cost;
		}
	}
	static int n,s,ans;
	static int a,b;
	static Apple num[]=new Apple[5005];
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		n=cin.nextInt();s=cin.nextInt();
		a=cin.nextInt();b=cin.nextInt();
		for(int i=0;i<n;i++) {
			num[i]=new Apple();         //不要忘记
			num[i].height=cin.nextInt();
			num[i].cost=cin.nextInt();
		}
		
		Arrays.sort(num,0,n, new Apple());   //观察参数
		
		for(int i=0;i<n&&s>=num[i].cost;i++) {
			if(num[i].height<=a+b) {
				ans++;
				s-=num[i].cost;
			}
		}
		System.out.println(ans);
	}

}