用于基本数据类型的数组排序，用到的是Arrays类下的重载静态方法sort( );

        只需要调用sort方法就行，传入数组名为实参。

例如，对整型数组进行排序。

public class ArraysTest {
	
	public static void main(String[]args) {
		
		int [] arr = new int[] {1,6,4,2,9,1,4};
		
		Arrays.sort(arr);
		
		System.out.println(Arrays.toString(arr)); //输出数组元素
		
		
		
	}
}

        运行结果为:

        Arrays.toString()也是一个重载方法，传入数组名就回返回一个包含该数组所有元素的字符串。格式是:[a,b,c,d ] ; 

        使用Arrays.sort()进行排序，进行是升序排序。

一、该类实现Comparable接口

        如果要对自定义类的对象数组进行排序呢。该类就需要实现Comparable接口，重写compareTo();在compareTo方法中需要表现出是对类的那个字段进行排序，并且可以升降排序。

下面对Person类举例，对其按age从大到小排序，如何age相等则按name从小到大排序。

定义Person类

public class Person implements Comparable<Person>{
	
	String name;
	int age;
	Person(){
		
	}
	Person(String name ,int age){
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public int compareTo(Person o) {
		if(o.age==this.age) {
			return this.name.compareTo(o.name);
		}
		return o.age-this.age;
	}
	
	public String toString() {
		
		return "(姓名:"+name+",年龄"+age+")";
	}
}

        如何排序，按什么字段来排序，完全取决于compareTo()方法。对其所需排序的字段进行相减就可以实现按照该字段排序了，如果是字符串则需要调用字符串的compareTo()方法返回一个整型

        之所以要重写toString方法，是因为使用输出方法Arrays.toString(Object o)需要识别对象数组中的每一个元素所需要表示的含义。

另外，当前Person类测试代码与上述整型数组排序代码在同一个main函数中，我不在想要去注释掉整型排序，之前学习了Junit工具，就使用了Junit工具来实现。

    @Test
	public void testPerson() {
		
		Person [] p1 =new Person[] {
			new Person("Ja",25),
			new Person("Ai",17),
			new Person("Aa",17),
			new Person("Lo",32),
			new Person("Hi",12),
			
		};
		
		Arrays.sort(p1);
		System.out.println(Arrays.toString(p1));
		
	}

输出结果为:

二、例题:

某小学最近得到了一笔赞助，打算拿出其中一部分为学习成绩优秀的前 55 名学生发奖学金。

期末，每个学生都有 33 门课的成绩:语文、数学、英语。

先按总分从高到低排序，如果两个同学总分相同，再按语文成绩从高到低排序，如果两个同学总分和语文成绩都相同，那么规定学号小的同学排在前面，这样，每个学生的排序是唯一确定的。

任务：先根据输入的 33 门课的成绩计算总分，然后按上述规则排序，最后按排名顺序输出前五名学生的学号和总分。

注意，在前 55 名同学中，每个人的奖学金都不相同，因此，你必须严格按上述规则排序。

例如，在某个正确答案中，如果前两行的输出数据(每行输出两个数:学号、总分) 是:

7 279
5 279

这两行数据的含义是:总分最高的两个同学的学号依次是 77 号、55 号。

这两名同学的总分都是 279279 (总分等于输入的语文、数学、英语三科成绩之和)，但学号为 77 的学生语文成绩更高一些。

如果你的前两名的输出数据是:

5 279
7 279

则按输出错误处理。

输入格式

输入文件包含 n+1n+1 行:

第 11 行为一个正整数 nn，表示该校参加评选的学生人数。

第 22 到 n+1n+1 行，每行有 33 个用空格隔开的数字，每个数字都在 00 到 100100 之间，第 jj 行的 33 个数字依次表示学号为 j−1j−1 的学生的语文、数学、英语的成绩。

每个学生的学号按照输入顺序编号为 1∼n1∼n (恰好是输入数据的行号减 11)。

所给的数据都是正确的，不必检验。

输出格式

输出文件共有 55 行，每行是两个用空格隔开的正整数，依次表示前 55 名学生的学号和总分。

数据范围

6≤n≤3006≤n≤300

输入样例：

6
90 67 80
87 66 91
78 89 91
88 99 77
67 89 64
78 89 98

输出样例：

6 265
4 264
3 258
2 244
1 237

        根据上述的内容可以做。

        代码:

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Person [] ps = new Person[n];
        for(int i =0;i<n;i++){
            Person p = new Person(i+1,sc.nextInt(),sc.nextInt(),sc.nextInt());
            ps[i] = p;
        }
        Arrays.sort(ps);
        for(int i = 0;i<5;i++){
            System.out.println(ps[i]);
        }
    }
}
class Person implements  Comparable<Person>{
    int id ;
    public int y;
    int s;
    int e;
    public int sum ;
    public Person(int id, int y, int s, int e) {
        this.id = id;
        this.y = y;
        this.s = s;
        this.e = e;
        this.sum = y+s+e;
    }



    @Override
    public int compareTo(Person o) {
        if(this.sum==o.sum){
            if(this.y==o.y){
                return this.id-o.id;
            }
            return o.y- this.y;
        }
        return o.sum-this.sum;
    }

    @Override
    public String toString() {
        return id +" "+sum;
    }
}

三、使用Arrays.sort(T[  ] a，Comparator<? super T> c)

        Person类不实现Comparable接口，在排序时重载compare方法就可。

        则上述可以改为:

    @Test
	public void testPerson() {
		
		Person [] p1 =new Person[] {
			new Person("Ja",25),
			new Person("Ai",17),
			new Person("Aa",17),
			new Person("Lo",32),
			new Person("Hi",12),
			
		};
		
		Arrays.sort(p1);
        Arrays.sort(p1, new Comparator<Person>() {

            @Override
            public int compare(Person o1, Logs o2) {

                if (o1.age == o2.age) {
                    return o1.name.compareTo(o2.name);
                }
                return o2.age - o1.age;
            }
        });
		System.out.println(Arrays.toString(p1));
		
    }