1. import java.util.ArrayList;
   
2. import java.util.Collections;
   
3. import java.util.Comparator;
   
4. import java.util.List;
   
5. 
   
6. public class CollectionsDemo {
   
7.         public static void main(String[]args)
   
8.         {
   
9.                 sortDemo();
   
10.         }
    
11.         public static void sortDemo()
    
12.         {
    
13.                 List<String> ss=new ArrayList<String>();
    
14.                 ss.add("abc");
    
15.                 ss.add("a");
    
16.                 ss.add("tbceet");
    
17.                 ss.add("zbcfd");
    
18.                 sop(ss);
    
19.                 Collections.sort(ss,new sortComparator());//这里编译不过去，问下为什么？
    
20.                 sop(ss);
    
21.         }
    
22.         class sortComparator implements Comparator<String>
    
23.         {
    
24.                 public int compare(String s1,String s2)
    
25.                 {
    
26.                         if (s1.length()>s2.length())
    
27.                                 return 1;
    
28.                         if (s1.length()<s2.length())
    
29.                                 return -1;
    
30.         
    
31.                                 return s1.compareTo(s2);
    
32.                         
    
33.                 }
    
34.         }
    
35.         public static void sop(Object obj)
    
36.         {
    
37.                 System.out.println(obj);
    
38.         }
    
39. 
    
40. }

复制代码

楼主，你这个问题很有意思哦，我给你的解决方法是
第一种解决方案：正常的比较器做法是不会作为内部类来使用的，你可以把按照正常的方式来，就没问题了。
代码就不贴了，你只需要把你的那个比较器别作为内部类来使用就行了，这个不用我细说了吧
第二种解决方案：如果楼主你真心的想用内部类来实现，那么给你的这个这个内部类来个静态修饰吧，就是让内部类和外部类在加载的时候保持一致的步调，代码如下：import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsDemo1 {
        public static void main(String[]args)
        {
                sortDemo();
        }
        public static void sortDemo()
        {
                List<String> ss=new ArrayList<String>();
                ss.add("abc");
                ss.add("a");
                ss.add("tbceet");
                ss.add("zbcfd");
                sop(ss);
                Collections.sort(ss,new sortComparator());
                sop(ss);
        }
        //在这里给你的内部类加个静态就哦了！！！
        static class sortComparator implements Comparator<String>
        {
                public int compare(String s1,String s2)
                {
                        if (s1.length()>s2.length())
                                return 1;
                        if (s1.length()<s2.length())
                                return -1;
        
                                return s1.compareTo(s2);
                        
                }
        }
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }

}
第三种解决方法：嘿嘿，楼主，这个方法估计你会蒙圈的，用匿名内部类来实现。代码如下：
Collections.sort(ss,new Comparator<String>(){
             public int compare(String s1,String s2){
                        if (s1.length()>s2.length())
                                return 1;
                        if (s1.length()<s2.length())
                                return -1;      
                                return s1.compareTo(s2);                     
                }
        });//将比较器作为匿名内部类来传递就不会出现错误了
求：加分！

陶锋 发表于 2012-7-21 22:07
类CollectionsDemo没有关闭的 } 这是一个问题；
还有问题，这里不能直接调用sop()方法，它和sortDemo()方法 ...

sop()方法是可以直接调用的，那里没问题。
问题出在Collections.sort(ss,new sortComparator());//这里编译不过去，问下为什么？
我的电脑是编译不过去，你的跑着有问题吗？

谢谢了，受教了。

1.这个程序中有几个角色，sortDemo和sop是静态方法，sortComparator是非静态内部类
2.sortDemo方法是类相关的，sortComparator非静态内部类是与field，方法，构造器和初始化块相似的类成员，它是实例相关的。在静态方法中，无法创建非静态内部类的实例。
3.因而有三种解法，一，将sortDemo和sortComparator都写为静态成员，二，将sortDemo和sortComparator都写为非静态成员，三，将sortDemo方法中的new sortComparator()改写为匿名内部类。