【从零开始的Java开发】1-6-1 集合排序：对整型和字符串、Comparator接口、Comparable接口

数组的排序

int[] arr= {1,2,3,4,5,1};
Arrays.sort(arr);
1
2

集合排序

使用Collections类的sort()方法；
sort(List list):根据元素的自然顺序指定列表按升序进行排序。

案例：对整型排序

public class IntSort {

	public static void main(String[] args) {
		// 对存储在List中的整型数据进行排序
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(9);
		list.add(0);
		list.add(2);

		System.out.println("排序前：");
		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i) + "  ");
		}

		System.out.println();
		Collections.sort(list);
		System.out.println("排序后：");
		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i) + "  ");
		}
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输出：

排序前：
1  9  0  2  
排序后：
0  1  2  9  
1
2
3
4

案例：对字符串进行排序

根据ASCII码进行排序。

public static void main(String[] args) {
		// 对存储在List中的整型数据进行排序
		List<String> list = new ArrayList<String>();
		list.add("2");
		list.add("1");
		list.add("a");
		list.add("JAVA");
		

		System.out.println("排序前：");
		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i) + "  ");
		}

		System.out.println();
		Collections.sort(list);
		System.out.println("排序后：");
		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i) + "  ");
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出：

排序前：
2  1  a  JAVA  
排序后：
1  2  JAVA  a  
1
2
3
4

Comparator接口

在Java.util包下。

• 强行对某个对象进行整体排序的比较函数
• 可以将Comparator传递给sort方法（如Collections.sort 或Arrays.sort ）
• int compare(T o1,T o2 )，比较用来排序的两个参数：o1o2返回正整数
• boolean equals(Object obj)指示某个其他对象是否“等于”此Comparator：此方法可以被Object类中的equals方法覆盖，不必重写

案例：对宠物猫分别按名字升序、年龄降序进行排列

核心代码：Collections.sort(list,new NameComparator());

按名字升序

代码：“名字比较器”的类，实现Comparator这个接口

//定义一个“名字比较器”的类，它实现了Comparator这个接口
public class NameComparator implements Comparator<Cat> {

	@Override
	public int compare(Cat o1, Cat o2) {
		String name1 = o1.getName();
		String name2 = o2.getName();
		int n = name1.compareTo(name2);
		return n;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12

代码：测试类

public static void main(String[] args) {
		// 按名字升序排序
		Cat hua = new Cat("huahua", 5, "英短");
		Cat fan = new Cat("fanfan", 2, "狸花");
		Cat mao = new Cat("maomao", 3, "中华田园猫");

		List<Cat> list = new ArrayList<Cat>();
		list.add(hua);
		list.add(fan);
		list.add(mao);

		// 排序前
		System.out.println("排序前：");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i).toString());
		}
		System.out.println();

		// 按名字升序排序——排序后
		Collections.sort(list, new NameComparator());
		System.out.println("排序后：");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i).toString());
		}
		System.out.println();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

输出：

排序前：
[姓名=huahua, 年龄=5, 品种=英短]
[姓名=fanfan, 年龄=2, 品种=狸花]
[姓名=maomao, 年龄=3, 品种=中华田园猫]

排序后：
[姓名=fanfan, 年龄=2, 品种=狸花]
[姓名=huahua, 年龄=5, 品种=英短]
[姓名=maomao, 年龄=3, 品种=中华田园猫]
1
2
3
4
5
6
7
8
9

按年龄降序
比较类：

//年龄降序比较器
public class AgeComparator implements Comparator<Cat> {

	@Override
	public int compare(Cat o1, Cat o2) {
		int age1 = o1.getMonth();
		int age2 = o2.getMonth();
		return age2 - age1;
	}
}
1
2
3
4
5
6
7
8
9
10

测试输出：

按年龄降序排序后：
[姓名=huahua, 年龄=5, 品种=英短]
[姓名=maomao, 年龄=3, 品种=中华田园猫]
[姓名=fanfan, 年龄=2, 品种=狸花]
1
2
3
4

Comparable接口

在Java.lang包下。

• 此接口强行对实现它的每个类的对象进行整体排序
• 这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法
• 对于集合，通过调用Collections.sort方法进行排序
• 对于数组，通过调用Arrays.sort方法进行排序
• int compareTo(T o)方法：对象小于、等于、大于指定对象，则分别返回负整数、0、或正整数

案例：对商品价格进行降序排列

核心代码：Collections.sort(list);

商品类：

public class Goods implements Comparable<Goods> {
	//属性和方法
	....
	//比较类
	@Override
	public int compareTo(Goods o) {
		double price1 = this.getPrice();
		double price2 = o.getPrice();
		int n = new Double(price2 - price1).intValue();
		return n;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

测试类：

public class GoodsTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Goods g1 = new Goods("S01", "电视", 2000);
		Goods g2 = new Goods("S02", "电脑", 6000);
		Goods g3 = new Goods("S03", "手机", 4000);

		List<Goods> list = new ArrayList<Goods>();
		list.add(g1);
		list.add(g2);
		list.add(g3);

		// 排序前
		System.out.println("排序前：");
		for (Goods l : list) {
			System.out.println(l.toString());
		}

		// 排序后
		Collections.sort(list);
		// 排序前
		System.out.println("排序前：");
		for (Goods l : list) {
			System.out.println(l.toString());
		}
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

输出：

排序前：
[商品编号=S01, 商品名字=电视, 商品价格=2000.0]
[商品编号=S02, 商品名字=电脑, 商品价格=6000.0]
[商品编号=S03, 商品名字=手机, 商品价格=4000.0]
排序前：
[商品编号=S02, 商品名字=电脑, 商品价格=6000.0]
[商品编号=S03, 商品名字=手机, 商品价格=4000.0]
[商品编号=S01, 商品名字=电视, 商品价格=2000.0]
1
2
3
4
5
6
7
8

总结

Comparator和Comparable的区别

Comparator：

• 位于java.util包
• 在要比较的类的外部实现该接口
• 调用sort方法时，要指定 Comparator的实现类

Comparable：

• 位于java.lang包
• 在要比较的类内实现该接口
• 调用sort方法时，只需要指定集合名即可

对于Comparator：

1. 实现要比较的类
2. 实现Comparator接口
3. 测试

对于Comparable：

1. 定义要比较的类，并在类内实现Comparable接口
2. 测试