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">