应用:集合排序

 能解决的问题：

1. 对集合进行排序

 

说明：

1. 本文主要演示对List(Array乱入)的排序,其他集合排序仿照本文思路
2. Set和Map的排序 可使用TreeSet、TreeMap
3. 想对一个List进行排序有2种方法（数组也适用）: 
   方法一：实现一个比较器Comparator。 
   方法二：List中的对象实现Comparable接口的compareTo方法。
4. 完成上面一点后，集合使用Collections.sort，数组使用Arrays.sort进行排序。
5. 本例将很多Java类写到了一个文件，这种写法主要是方便大家拷贝，实际效果基本等同于分开写。

 

程序演示： 放大

1. package com.cxy.collection;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Arrays;  
5. import java.util.Collections;  
6. import java.util.Comparator;  
7. import java.util.HashSet;  
8. import java.util.List;  
9. import java.util.Set;  
10.   
11. /** 
12.  * @author cxy @ www.cxyapi.com 
13.  */  
14. public class ListSortTest  
15. {  
16.     public static void main(String[] args)  
17.     {  
18.         List <Student> l=new ArrayList();  
19.         Student s1 =new Student("小明",76);  
20.         Student s2 =new Student("小黑",99);  
21.         Student s3 =new Student("小白",60);  
22.         l.add(s1);  
23.         l.add(s2);  
24.         l.add(s3);  
25.         System.out.print("List排序前：");  
26.         System.out.println(l);  
27.         //第一种方式：普通的对象，然后实现一个比较器，使用下面的方法进行排序  
28.         Collections.sort(l,new StudentComparator());  
29.         System.out.print("List排序后：");  
30.         System.out.println(l);  
31.         System.out.println("=======================");  
32.           
33.         //乱入的数组  
34.         Student[] sa={s1,s2,s3};  
35.         System.out.print("数组排序前：");  
36.         System.out.println(sa[0].toString()+sa[1]+sa[2]);  
37.         Arrays.sort(sa,new StudentComparator());  
38.         System.out.print("数组排序后：");  
39.         System.out.println(sa[0].toString()+sa[1]+sa[2]);  
40.           
41.         System.out.println("============下面的都是ComparableStudent演示===========");  
42.         //对象自身拥有排序能力  
43.         List<ComparableStudent> l1=new ArrayList();  
44.         ComparableStudent s11 =new ComparableStudent("较劲的小明",76);  
45.         ComparableStudent s22 =new ComparableStudent("较劲的小黑",99);  
46.         ComparableStudent s33 =new ComparableStudent("较劲的小白",60);  
47.         //PS：较劲的意思可以理解为 争强好胜 o_o  
48.         l1.add(s11);  
49.         l1.add(s22);  
50.         l1.add(s33);  
51.         System.out.print("List排序前：");  
52.         System.out.println(l1);  
53.         Collections.sort(l1);  
54.         System.out.print("List排序后：");  
55.         System.out.println(l1);  
56.         System.out.println("=======================");  
57.           
58.         //数组再次乱入  
59.         ComparableStudent[] cs={s11,s22,s33};  
60.         System.out.print("数组排序前：");  
61.         System.out.println(cs[0].toString()+cs[1]+cs[2]);  
62.         Arrays.sort(cs);  
63.         System.out.print("数组排序后：");  
64.         System.out.println(cs[0].toString()+cs[1]+cs[2]);  
65.     }  
66. }  
67.   
68. //一个普通的学生类，按照学生的学习成绩进行排序  
69. //这里只是为了快速展示排序而设计的“简陋”的类，所以不要追究 你这个类设计的不科学，成员变量应该私有等问题。  
70. class Student  
71. {  
72.     public String name;  //姓名  
73.     public int score;  //分数  
74.       
75.     Student(String name,int score)  
76.     {  
77.         this.name=name;  
78.         this.score=score;  
79.     }  
80.       
81.     @Override  
82.     public String toString()  
83.     {  
84.         return "["+name+":"+score+"]";  
85.     }  
86. }  
87.   
88. //一个学生的比较器，泛型定义了比较的范围是Student，也可以不定义泛型，再在compare里面进行强制转换  
89. class StudentComparator  implements Comparator<Student>  
90. {  
91.     @Override  
92.     public int compare(Student s1, Student s2)  
93.     {  
94.         if(s1.score>s2.score) return 1;  
95.         else if(s1.score<s2.score) return -1;  
96.         else return 0;  
97.     }  
98. }  
99.   
100. /** 
101.  * 一个实现了Comparable接口的compareTo方法的学生类 
102.  * compareTo的实现方式： 
103.  *   x.compareTo(y)为例，当x小于y的时候，返回一个负数。当x大于y的时候，返回一个正数。相等的时候返回0. 
104.  */  
105. class ComparableStudent implements Comparable<ComparableStudent>  
106. {  
107.     public String name;  //姓名  
108.     public int score;  //分数  
109.       
110.     ComparableStudent(String name,int score)  
111.     {  
112.         this.name=name;  
113.         this.score=score;  
114.     }  
115.       
116.     @Override  
117.     public int compareTo(ComparableStudent s)  
118.     {  
119.         if(score>s.score) return 1;  
120.         else if(score<s.score) return -1;  
121.         else return 0;  
122.     }  
123.       
124.     @Override  
125.     public String toString()  
126.     {  
127.         return "["+name+":"+score+"]";  
128.     }  
129. }