1. import java.util.*;
   
2. public class GenericDemoT {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 //ArrayList<String> a1 = new ArrayList<String>(new MyLenCom());     //代码1
   
6.                 TreeSet<String> a1 = new TreeSet<String>(new MyLenCom());          //代码2
   
7.                 //<String>代表要村的元素的类型
   
8.                 a1.add("abcd2");
   
9.                 a1.add("aadc");
   
10.                 a1.add("cdfgd2");
    
11.                 a1.add("123");
    
12.                 a1.add(",..,m,");
    
13.                
    
14.                 Iterator<String> it = a1.iterator();
    
15.                 while(it.hasNext())
    
16.                 {
    
17.                         String s = it.next();
    
18.                         System.out.println(s+"....."+s.length());
    
19.                 }
    
20.                
    
21.         }
    
22. }
    
23. class MyLenCom implements Comparator
    
24. {
    
25.         public int compare(Object o1,Object o2)
    
26.         {
    
27.                 String s1 = (String)o1;
    
28.                 String s2 = (String)o2;
    
29.                
    
30.                 int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
    
31.                 if(num ==0)
    
32.                 {
    
33.                         return s1.compareTo(s2);
    
34.                 }
    
35.                 return num;
    
36.         }
    
37. }

复制代码

疑问：为什么代码2能编译通过，而代码1就不能？ArrayList和TreeSet在这一点有什么区别？

ArrayList没有带比较器的构造方法，TreeSet就有，这个可以从API里面查到；其根本的区别就是List是有序的，这个有序是按照存的顺序而言，而且元素是可以重复的（没办法进行比较），set则是不允许重复，而且是原本无序的，可以加进比较器排序

只有类提供了这个构造方法才能new 对象，而ArrayList没有提供，所以ArrayList不具备自定义比较器的方法。
TreeSet是二叉树数据结构，存储在Set中的元素不允许重复，而且TreeSet具有按字母顺序排序的功能。如果不是我们所想要的可以自定义比较器。
就是让自定义的比较了实现Comparator父类，并且重写其compare比较方法。

在java基础中只有说到对set进行排序用这种做法，但并没有提到对于list集合，这种方式也可行的，我觉得应该是list和set集合之间的不同之处导致的，比如说，set存在唯一性的元素，无序，但是list是有序的，元素可以重复的。但是我们也可以通过自定义实现larrayist的排序，通过转变成数组，再排序实现的排序方式，如果要实现唯一性的话，可以自己再加点判断就行了。下面是我的代码。

1. package cn.itcast.Test;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. import java.util.List;
   
6. 
   
7. public class ArrayListTest {
   
8. 
   
9.         /**
   
10.          * @param args
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 // TODO Auto-generated method stub
    
14. 
    
15.                 List<String> arr=new ArrayList<String>();
    
16.                 arr.add("aaa");
    
17.                 arr.add("abc");
    
18.                 arr.add("aba");
    
19.                 arr.add("a");
    
20.                 arr.add("bbbaa");
    
21.                 arr.add("aab");
    
22.                 arr.add("baa");
    
23.                 arr.add("aaaaa");
    
24.                 arr.add("aaa");
    
25.                
    
26.                 Object[] array = arr.toArray();
    
27. 
    
28.                 sort(array);
    
29.                
    
30.                 Iterator it = arr.iterator();
    
31.                 while(it.hasNext()){
    
32.                         Object o1=it.next();
    
33.                         System.out.println(o1.toString());
    
34.                 }
    
35.                 System.out.println("-------------after sort-------------");
    
36.                 for(int i=0;i<array.length;i++){
    
37.                         System.out.println(array[i]);
    
38.                 }
    
39.         }
    
40. 
    
41.         private static void sort(Object[] array) {
    
42.                 // TODO Auto-generated method stub
    
43.                 for(int i=0;i<array.length-1;i++){
    
44.                         for(int j=i+1;j<array.length;j++){
    
45.                                
    
46.                                 compare(array,i,j);
    
47.                         }
    
48.                 }
    
49.         }
    
50. 
    
51.         private static void compare(Object[] array, int i, int j) {
    
52.                 // TODO Auto-generated method stub
    
53.                 String a1=(String)array[i];
    
54.                 String a2=(String)array[j];
    
55.                 if(a1.length()>a2.length()){
    
56.                         String temp=(String)array[i];
    
57.                         array[i]=array[j];
    
58.                         array[j]=temp;
    
59.                 }
    
60.                 if(a1.length()==a2.length()){
    
61.                         System.out.println(a1+"   "+a2);
    
62.                         System.out.println(a1.compareTo(a2));
    
63.                         if(a1.compareTo(a2)>0){
    
64.                             
    
65.                                 String temp=(String)array[i];
    
66.                                 array[i]=array[j];
    
67.                                 array[j]=temp;
    
68.                         }
    
69.                        
    
70.                 }
    
71.         }
    
72. 
    
73. }
    
74. 
    
75.        
    

复制代码

我截了个API的图，可以看到ArrayList没有传比较器的构造方法，因为List集合本身是有序的，所以这个是没有必要的。如果想按自己的规则排序可以通过复写类中的equals()方法