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
最后，上面的兩個實例只要改變相應的待排序數據的形式（數組，集合），都可以替換使用。