Java中常用的数组或集合排序的方法有两个，一个是java.util.Arrays中的静态方法Arrays.sort（），还有一个是java.util.Collections中的静态方法的Collections.sort()方法，下面分别介绍两种用法。
一.java.util.Arrays中的静态方法Arrays.sort（）
Arrays中的sort()方法主要是针对各种数据类型（基本数据类型和引用对象类型）的数组元素排序。
.......
关于引用对象类型数组的排序sort()方法要用到接口Comparator<T>，对其排序内部的比较函数compare()进行重写，以便于我们按照我们的排序要求对引用对象数组极性排序，默认是升序排序，但可以自己自定义成降序排序。关于Comparator<T>的介绍见官方文档
sortpublic static <T> void sort(T[] a,
Comparator<? super T> c)
sortpublic static <T> void sort(T[] a,
int fromIndex,
int toIndex,
Comparator<? super T> c)
|
下面上实例：
package test;
import java.util.Arrays;
import java.util.Comparator;
//用Arrays中的sort()对数组进行排序
public class test4 {
//年龄比较器
Comparator<student> comparatorAge =new Comparator <student>(){
public int compare(student p1,student p2){
if (p1.getAge()>p2.getAge())
return 1;
else if (p1.getAge()<p2.getAge())
return -1;
else
return 0;
}
};
//成绩比较器
Comparator<student> comparatorGrade =new Comparator <student>(){
public int compare(student p1,student p2){
if (p1.getGrade()>p2.getGrade())
return 1;
else if (p1.getGrade()<p2.getGrade())
return -1;
else
return 0;
}
};
public student [] ageSort(student[] s){
Arrays.sort(s,comparatorAge);
return s;
}
public student [] gradeSort(student[] s){
Arrays.sort(s,comparatorGrade);
return s;
}
public static void main(String[] args) {
test4 tt=new test4();
student p1 = new student() ;
p1.setAge( 10 );
p1.setName( "p1" );
p1.setGrade( 98 );
student p2 = new student() ;
p2.setAge( 30 );
p2.setName( "p2" );
p2.setGrade( 70 );
student p3 = new student() ;
p3.setAge( 20 );
p3.setName( "p3" );
p3.setGrade( 83 );
student p4 = new student() ;
p4.setAge( 15 );
p4.setName( "p4" );
p4.setGrade( 80 );
student [] list = {p1,p2,p3,p4} ;
student []agePrint= tt.ageSort(list);
for (student ss : agePrint) {
System.out.println("student age sort ," + ss.getName() + " " + ss.getAge() +" " +ss.getGrade());
}//按年龄排序
student []gradePrint= tt.gradeSort(list);
for (student ss : gradePrint) {
System.out.println("student grade sort ," + ss.getName() + " " + ss.getAge() +" " +ss.getGrade());
}//按成绩排序
}
}
//创建一个类型，用于比较的引用对象类型
class student{
private String name;
private int age;
private float grade;
public void setName(String name){
this.name=name;
}
public void setAge(int age) {
this.age = age;
}
public void setGrade(float grade) {
this.grade = grade;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public float getGrade() {
return grade;
}
}
结果如下：
student age sort ,p1 10 98.0 student age sort ,p4 15 80.0 student age sort ,p3 20 83.0 student age sort ,p2 30 70.0 student grade sort ,p2 30 70.0 student grade sort ,p4 15 80.0 student grade sort ,p3 20 83.0 student grade sort ,p1 10 98.0
二. java.util.Collections中的静态方法的Collections.sort()
java.util.Collections中的静态方法的Collection.sort()主要是针对集合框架中的动态数组，链表，树，哈希表等（ ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap ）进行排序。
关于Comporator 的介绍和上面相同，主要是针对里面compare()的重写
下面上实例：
package test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
//用Collections的sort()方法对集合进行排序。
/*
* 题目：
* 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
* 例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
*/
public class test3 {
public String PrintMinNumber(Integer [] s) {
if(s==null) return null;
String s1="";
ArrayList<Integer> list=new ArrayList<Integer>(Arrays.asList(s));
// for(int i=0;i<s.length;i++){
// list.add(s[i]);
// }
Collections.sort(list,new Comparator<Integer>(){//数组里的数两两组合比较，按照比较值更得的顺序升序排序
public int compare(Integer str1,Integer str2){
String s1=str1+""+str2;
String s2=str2+""+str1;
return s1.compareTo(s2);//变成-s1.compareTo(s2)就是降序排序了
}
});
for(int j:list){
System.out.println("输出为:"+j);
s1+=j;
}
return s1;
}
public static void main(String[] args) {
Integer [] list={3,32,321};
test3 demo=new test3();
System.out.println(demo.PrintMinNumber(list));
}
}
结果如下：
输出为:321 输出为:32 输出为:3 321323
最后，上面的两个实例只要改变相应的待排序数据的形式（数组，集合），都可以替换使用。