Java学习笔记--- Java对List集合的排序

转载博客地址：

http://blog.csdn.net/liaodehong/article/details/50573804

由于其功能性和灵活性，ArrayList是 Java 集合框架中使用最为普遍的集合类之一。ArrayList 是一种 List 实现，它的内部用一个动态数组来存储元素，因此 ArrayList 能够在添加和移除元素的时候进行动态的扩展和缩减。

使用Collections工具类进行排序:

使用Collections排序非常简单，我们只需要把实现了Comparable接口的类传入里面调用一下Collections.sort() 方法就可以对其进行排序了。

一般使用这个方法最多的就是对string和Integer进行排序，因为他们内部都很好的实现了Comparable化这个接口。

[java] view plain copy

 print?

1. public int compareTo(String anotherString) {  
2.        int len1 = value.length;  
3.        int len2 = anotherString.value.length;  
4.        int lim = Math.min(len1, len2);  
5.        char v1[] = value;  
6.        char v2[] = anotherString.value;  
7.   
8.        int k = 0;  
9.        while (k < lim) {  
10.            char c1 = v1[k];  
11.            char c2 = v2[k];  
12.            if (c1 != c2) {  
13.                return c1 - c2;  
14.            }  
15.            k++;  
16.        }  
17.        return len1 - len2;  
18.    }  

compareTo这个方法放到后面再细说。现在我们来检验一下Collections.sort对字符串的排序。

Collections.sort(list, new PriceComparator());的第二个参数返回一个int型的值，就相当于一个标志，告诉sort方法按什么顺序来对list进行排序。

[html] view plain copy

 print?

1. public static void main(String[] args) {  
2.         List<String> list=new ArrayList<String>();  
3.         list.add("c");  
4.         list.add("b");  
5.         list.add("8d");  
6.         Collections.sort(list);  
7.         System.out.println(list);  
8.     }  

内部的排序方法是按照字母的顺序一个一个来比较的，比如上面这段代码，打印的结果是[8d, b, c]，这里按说8d要比c大，但是8d却排在最前面，因为他只对比首位，只有首位相同的时候，才会按照位数依次往下比较；比如下面这段代码:

[java] view plain copy

 print?

1. public static void main(String[] args) {  
2.         List<String> list=new ArrayList<String>();  
3.         list.add("a1");  
4.         list.add("a2aaaaaaaa");  
5.         list.add("a3aaaa");  
6.         Collections.sort(list);  
7.         System.out.println(list);  
8.     }  

结果为：[a1, a2aaaaaaaa, a3aaaa]

使用Comparable排序ArrayList

Comparable 是带有单一 compareTo()方法的接口。一个实现了 Comparable 接口的类对象可以与其它同类型的对象进行比较，实现 Comparable 接口的类需要重写 compareTo()方法，这个方法接收一个同类型的对象，并实现这个对象和传递给方法的另一个对象比较的逻辑。compareTo()方法返回Int类型的比较结果，分别代表下面的含义：
正值表示当前对象比传递给 comPareTO()的对象大
负值表示当前对象比传递给 comPareTO()的对象小
零表示两个对象相等

举一个例子，假如我们现在有一个Student类，类里面有两个变量，一个名称，一个年龄，假如我们需要按年龄进行排序的话，就需要重写comPareTO()这个方法;

[java] view plain copy

 print?

1. public class Student implements Comparable{  
2.     private String name;  
3.     private Integer age;  
4.     public String getName() {  
5.         return name;  
6.     }  
7.     public void setName(String name) {  
8.         this.name = name;  
9.     }  
10.     public Integer getAge() {  
11.         return age;  
12.     }  
13.     public void setAge(Integer age) {  
14.         this.age = age;  
15.     }  
16.       
17.     @Override  
18.     public String toString() {  
19.         return "Student [name=" + name + ", age=" + age + "]";  
20.     }  
21.     public Student() {  
22.         super();  
23.     }  
24.     @Override  
25.     public int compareTo(Object o) {  
26.         return (this.getAge() < ((Student) o).getAge() ? -1 :  
27.              (this.getAge() == ((Student) o).getAge() ? 0 : 1));  
28.     }  

上面我们实现了基于年龄的比较，有很多人喜欢将(this.getAge() –((Student) o).getAge())作为返回的比较结果。尽管使用这种 return 语句看上去似乎很吸引人，并且也不会对我们的例子造成影响，我的建议是远离这种语句。想象一下，比较整数值，其中有一个或者两个都是负数的结果。这会导致一些错误，让你的程序行为不定，而且更重要的是，这样的错误是很细微的，尤其是在大型的企业应用中很难检测出来。

使用 Comparator 排序 ArrayList

Comparator 接口与Comparable 接口相似也提供了一个单一的比较方法叫作 compare()。然而，与 Comparable的 compareTo()方法不同的是，这个 compare()接受两个同类型的不同对象进行比较。

[java] view plain copy

 print?

1. public class Student{  
2.     private String name;  
3.     private Integer age;  
4.     public String getName() {  
5.         return name;  
6.     }  
7.     public void setName(String name) {  
8.         this.name = name;  
9.     }  
10.     public Integer getAge() {  
11.         return age;  
12.     }  
13.     public void setAge(Integer age) {  
14.         this.age = age;  
15.     }  
16.       
17.     @Override  
18.     public String toString() {  
19.         return "Student [name=" + name + ", age=" + age + "]";  
20.     }  
21.     public static Comparator ageComparator = new Comparator() {  
22.          @Override  
23.         public int compare(Object o1, Object o2) {  
24.              return ( ((Student) o1).getAge() < ((Student) o2).getAge() ? -1 :  
25.              (((Student) o1).getAge() ==((Student) o2).getAge() ? 0 : 1));  
26.              }  
27.          };  
28.     public Student() {  
29.         super();  
30.     }  
31.     public static void main(String[] args) {  
32.         Student s=new Student();  
33.         s.setName("张三");  
34.         s.setAge(17);  
35.         Student st=new Student();  
36.         st.setName("李四");  
37.         st.setAge(-1);  
38.         List<Student> list=new ArrayList<Student>();  
39.         list.add(s);  
40.         list.add(st);  
41.         Collections.sort(list,ageComparator);  
42.         System.out.println(list);  
43.     }  
44.   
45. }  

总结：有很多人倾向于不要使用接口，因为这样会提高类的耦合度，选择方法一直是我们所纠结的地方，其实一个 使用Comparable 对象可以说“我可以自己与另外一个对象比较”而一个使用 Comparator 对象可以说“我可以比较两个不同的对象”。你不能说一个接口比另一个要好。选择的接口取决于你需要实现的功能。