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 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);
}
}