java中的排序問題

很多時候我們需要對數組或是集合中的元素進行排序，對數組進行排序的時候，我們可以使用循環比較的方式定義自己的排序規則，如：插入排序、冒泡排序之類的，但是自己定義排序規則比較麻煩，而且不能對集合中的元素進行排序。java中定義了一個用來幫助進行排序的接口Comparable接口，Comparable<T>接口是一個泛型接口，泛型參數就是要進行排序的對象類型。關於泛型接口的使用參見http://blog.csdn.net/u010980545/article/details/21041707。所有實現了該接口的類的對象所組成的數組或者集合都能夠使用sort方法進行排序，默認的順序是初始化的順序，也可以通過重載compareTo方法來按照自己定義的規則進行排序。

1、使用Arrays中的sort方法對數組進行排序

Arras類中的sort方法能用來對基本的數組類型（int、String、Long、short、char、byte、float、double）和字符串數組進行排序，默認的排序規則是按ASCII表中的值進行升序排列。可以將數組中全部元素進行排序，也可以只對指定範圍的元素進行排序。

public class Arrays_basic {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 對數組中所有的元素進行排序,這裏列除了兩個，其他的基本的數據類型數組都是一樣的
		int[] integer_1 = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
		String[] str = { "abc", "abdc", "bca", "cbad", "ABC" };
		Arrays.sort(integer_1);
		Arrays.sort(str);
		for (int i = 0; i < integer_1.length; i++) {
			System.out.print(integer_1[i] + " ");
		}
		System.out.print("\n");
		for (int i = 0; i < str.length; i++) {
			System.out.print(str[i] + " ");
		}

		// 對數組中的指定位置進行排序
		int[] integer_2 = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
		Arrays.sort(integer_2, 3, 7);//把腳標爲3到7的元素進行排序
		System.out.print("\n");
		for (int i = 0; i < integer_2.length; i++) {
			System.out.print(integer_2[i] + " ");
		}
	}
}

結果：

0 1 2 3 4 5 6 7 8 9 
ABC abc abdc bca cbad 
9 8 7 3 4 5 6 2 1 0 

在上面的代碼中，只列出了int型的數組，對於其他的基本類型的數組，有對應的重載的sort方法。

分析對字符串數組進行排的結果會發現，當字符串的第一個元素相同的時候，會比較第二個元素，後面都一次類推。而且排序的時候不會考慮字符串的長度。

Arrays中的sort方法也能用來對一般類型的對象數組進行排序，但是數組中的元素必須實現了Comparable接口，我們可以在覆蓋接口中的compareTo方法的時候定義自己的排序規則。

public class Arrays_object {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		People_1[] peoples = new People_1[3];
		peoples[0] = new People_1("張三", 20);
		peoples[1] = new People_1("李四", 22);
		peoples[2] = new People_1("王五", 21);

		Arrays.sort(peoples);
		for (int i = 0; i < peoples.length; i++)
			System.out.println(peoples[i]);
	}

}

class People_1 implements Comparable<People_1> {
	public String name;
	public int age;
	public int id;

	public People_1(String name, int age) {
		this.name = name;
		this.age = age;
		Random ID = new Random();
		id = ID.nextInt(10);
	}
	
	public String toString(){
		return "name=" + name + " age=" + age + " id=" + id;
	}

	@Override
	public int compareTo(People_1 other) { //other表示的是要跟當前對象進行比較的對象
		// TODO Auto-generated method stub
		return age > other.age ? 1 : (age < other.age ? -1 : 0);
	}
}

輸出結果：

name=張三 age=20 id=0
name=王五 age=21 id=5
name=李四 age=22 id=1

結果是按年齡進行升序排列，如果把compareTo方法中的age都換成id，結果爲：

name=李四 age=22 id=3
name=張三 age=20 id=7
name=王五 age=21 id=9

結果過是按照id進行升序排列，如果再把返回語句中的-1和1互換，結果過爲：

name=李四 age=22 id=7
name=張三 age=20 id=4
name=王五 age=21 id=1

結果是按照id進行降序排列

通過這幾個結果過的比較，發現完全可以通過覆寫compareTo方法來定義自己的排序規則。

當然，也可以像第一個例子中一樣，只對數組的部分元素進行排序，其他的元素保持初始化的順序。

2、使用Collections中的sort方法對集合進行排序（跟對普通對象數組中的元素進行排序差不多）

集合中的元素也必須實現Comparable接口。

public class Collections_list {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<People_2> peoples = new ArrayList<People_2>();
		peoples = Arrays.asList(new People_2("張三", 20), new People_2("李四", 22),
				new People_2("王五", 21));

		Collections.sort(peoples);
		for (People_2 people : peoples)
			// 此處會對Employee對象進行排序，因爲該對象繼承了Comparable接口
			System.out.println(people);
	}
}

class People_2 implements Comparable<People_2> {
	public String name;
	public int age;
	public int id;

	public People_2(String name, int age) {
		this.name = name;
		this.age = age;
		Random ID = new Random();
		id = ID.nextInt(10);
	}

	public String toString() {
		return "name=" + name + " age=" + age + " id=" + id;
	}

	@Override
	public int compareTo(People_2 other) { // other表示的是要跟當前對象進行比較的對象
		// TODO Auto-generated method stub
		return age > other.age ? 1 : (age < other.age ? -1 : 0);
	}
}

3、Comparator接口

從上面的例子中可以看出實現了Comparable接口的類的對象所組成的數組或者集合都能夠用Arrays或者Collections中的sort方法進行排序，而且我們可以根據需要指定排序的依據，但是通過這種方法進行排序有一點不好的就是，每一個被排序的元素必須實現這個接口。如果在這樣一種情況下：當定義一個類的時候並沒有想到要對這個類的對象所組成的數組或者集合進行排序，等定義完之後發現需要進行排序了，但是又不想去改變這個類，上面的做法就行不通了，此時可以使用Comparator接口。

public class Comparator implements java.util.Comparator<People_3> {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		People_3[] peoples = { new People_3("張三", 20), new People_3("李四", 22),
				new People_3("王五", 21) };

		Arrays.sort(peoples, new Comparator());
		for (People_3 p : peoples) {
			System.out.println(p);
		}
	}

	@Override
	public int compare(People_3 p1, People_3 p2) { //排序規則可以在重寫這個方法的時候定義
		// TODO Auto-generated method stub
		return p1.age - p2.age;
	}
}

class People_3 {
	public String name;
	public int age;
	public int id;

	public People_3(String name, int age) {
		this.name = name;
		this.age = age;
		Random ID = new Random();
		id = ID.nextInt(10);
	}

	public String toString() {
		return "name=" + name + " age=" + age + " id=" + id;
	}
}

總結一下：
一、Arrays中的sort方法可以用於對基本類型的數組的元素進行排序，也可以對普通類型的對象數組進行排序，但是數組中的對象必須實現Comparable接口；
二、Collections中的sort方法只能用來對集合中的元素進行排序，而且元素必須是實現了Comparable接口的類的對象，排序的依據可以在實現compareTo方法的時候定義；

三、Comparable接口和Comparator接口的比較：凡是實現了Comparable接口的類的對象都能夠被比較，凡是實現了Comparator接口的類本身就是一個比較器，能夠對其他的類的對象進行比較。所有常見的排序算法中，除了基數排序外，都是基於比較的，因此這兩個接口和sort方法結合起來就能很方便地對元素集合進行排序。

<pre code_snippet_id="240931" snippet_file_name="blog_20140317_2_2084513" name="code" class="java"><pre code_snippet_id="240931" snippet_file_name="blog_20140317_2_2084513">