1. import java.util.Comparator;
   
2. import java.util.TreeSet;
   
3. class Com
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                
   
8.                 TreeSet ts = new TreeSet(new Demo2013());
   
9.                 ts.add("f8");
   
10.                 ts.add("25d55");
    
11.                 ts.add("1d1");
    
12.                 ts.add("8d56");
    
13.                 ts.add("25555");
    
14.                 ts.add("8d56");
    
15. 
    
16.                 System.out.println(ts);
    
17. 
    
18.         }
    
19. }
    
20. 
    
21. class Demo2013 implements Comparator
    
22. {
    
23.         public int compare(Object o1,Object o2)
    
24.         {
    
25.                 String s1 =(String)o1;
    
26.                 String s2 =(String)o2;
    
27.                
    
28.                 if (s1.length() > s2.length())
    
29.                 {
    
30.                         return 1;
    
31.                 }
    
32.                 if (s1.length() == s2.length())
    
33.                 {
    
34.                         return s1 ; //打印s1提示错误: 不兼容的类型,怎么才能把这里的s1打印出来
    
35.                 }
    
36.                 return -1;
    
37.         }
    
38. }
    

复制代码

直接在
if (s1.length() == s2.length())

                {
                        System.out.pringln(s1);
                        return s1 ; //打印s1提示错误: 不兼容的类型,怎么才能把这里的s1打印出来

          }
打印不就行了。
返回的必须是int类型，因为你是实现Comparable接口的方法，返回类型必须和接口设计的方法一致。

楼主，你的问题是：输入相同重复的数据。不是长度相同的数据哦。所以你的if判断错了。

1. package com.itheima;
   
2. import java.util.Comparator;
   
3. import java.util.TreeSet;
   
4. class test
   
5. {
   
6.         public static void main(String[] args)
   
7.         {
   
8.                
   
9.                 TreeSet ts = new TreeSet(new Demo2013());
   
10.                 ts.add("f8");
    
11.                 ts.add("25d55");
    
12.                 ts.add("1d1");
    
13.                 ts.add("8d56");
    
14.                 ts.add("25555");
    
15.                 ts.add("8d56");
    
16.                
    
17.                 System.out.println(ts);
    
18. 
    
19.         }
    
20. }
    
21. 
    
22. class Demo2013 implements Comparator
    
23. {
    
24.         public int compare(Object o1,Object o2)
    
25.         {
    
26.                 String s1 =(String)o1;
    
27.                 String s2 =(String)o2;
    
28.             
    
29.                
    
30.                 if (s1.length() > s2.length())
    
31.                 {
    
32.                         return 1;
    
33.                 }
    
34.                 if (s1 == s2)
    
35.                 {                            
    
36.                         System.out.println(s1+"+++"+s2);
    
37.                 }
    
38.                 return -1;
    
39.         }
    
40. }

复制代码

我改了一下代码，但是打印结果里面是
f8+++f8
8d56+++8d56

显然f8不是我们所要的。
我又想从内存的地址进行比较试图删除f8（因为两个f8的地址相同，但是两个8d56的地址不同）

但是以我现在所学，java好像不能直接对内存操作。

让我们一同期待高手吧

return 的返回类型须与函数上标明的一致，s1是String 不是int 所以返回类型错误。如果要打印只有像1楼那样直接在函数里输出。

               if (s1.length() == s2.length())
                {
                           System.out.println("s1="+s1);
                        //return s1.compareTo(s2) ;
                           if(s1.equals(s2))
                               return 1;
                           return 1;
                }
把上述代码中的第二个if代码块改成就样就可以了，要知道compare方法的返回值是int，因此不能在代码中return s1.因为s1是字符串类型。想要在内存中删除重复元素，只要把返回值改成0就可以了。

1. import java.util.Comparator;
   
2. import java.util.TreeSet;
   
3. class Com
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                
   
8.                 TreeSet ts = new TreeSet(new Demo2013());
   
9.                 ts.add("f8");
   
10.                 ts.add("25d55");
    
11.                 ts.add("1d1");
    
12.                 ts.add("8d56");
    
13.                 ts.add("25555");
    
14.                 ts.add("8d56");
    
15. 
    
16.                 System.out.println(ts);
    
17. 
    
18.         }
    
19. }
    
20. 
    
21. class Demo2013 implements Comparator
    
22. {
    
23.         public int compare(Object o1,Object o2)
    
24.         {
    
25.                 String s1 =(String)o1;
    
26.                 String s2 =(String)o2;
    
27.                
    
28.                 if (s1.length() > s2.length())
    
29.                 {
    
30.                         return 1;
    
31.                 }
    
32.                 if (s1.length() == s2.length())
    
33.                 {        System.out.println(s1);
    
34.                         return 0 ; //打印s1提示错误: 不兼容的类型,怎么才能把这里的s1打印出来
    
35.                 }
    
36.                 else
    
37.                 return -1;
    
38.         }
    
39. }

复制代码

输出的结果

25555
8d56
[f8, 1d1, 8d56, 25d55]

有两个重复的记录 对字符串长度进行排序

public static void main(String[] args) {
                Set<String> set = new TreeSet<String>(new Comparator<String>() {

                        @Override
                        public int compare(String o1, String o2) {
                                int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
                                if(num==0)
                                {        
                                        if(o1.equals(o2))             //这里加个判断来打印你要的结果
                                                System.out.println(o1+"---"+o2);
                                        return o1.compareTo(o2);
                                }
                                return num;
                        }
                });
               
                set.add("2345");
                set.add("23456");
                set.add("234");
                set.add("23");
                set.add("2345");
                set.add("1345");
               
                System.out.println(set);
        }
这样写就可以了
运行结果：
2345---2345
[23, 234, 1345, 2345, 23456]

1. import java.util.Comparator;
   
2. import java.util.TreeSet;
   
3. class Com
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                
   
8.                 TreeSet<String> ts = new TreeSet<String>(new Demo2013());
   
9.                 ts.add("25d55");
   
10.                 ts.add("f8");  
    
11.                 ts.add("1d1");
    
12.                 ts.add("8d56");
    
13.                 ts.add("25555");
    
14.                 ts.add("8d56");
    
15. 
    
16.                 System.out.println(ts);
    
17. 
    
18.         }
    
19. }
    
20. 
    
21. class Demo2013 implements Comparator<String>
    
22. {
    
23.         public int compare(String s1,String s2)
    
24.         {
    
25.                // System.out.println(s1+"...compareTo..."+s2);
    
26.                 if (s1.length() > s2.length())
    
27.                 {
    
28.                         return 1;
    
29.                 }
    
30.                 if (s1.length() == s2.length())
    
31.                 {
    
32.                                         if(s1.equals(s2))
    
33.                                         {
    
34.                                                 System.out.println(s1+"=="+s2);
    
35.                                         }
    
36.                                         return s1.compareTo(s2);        
    
37.                 }
    
38.                
    
39.                                 return -1;
    
40.                                 
    
41.         }
    
42. }
    

复制代码

输出的结果是


因为TreeSet在排序时 第一个存入的元素会和自己比较一下，所以最终的结果不是正确的结果。但是因为集合中存入字符串时，相同的字符串对应的hashCode是相同的，所以不能通过hashCode来去掉显示的第一个重复元素。
希望有高手来通过TreeSet底层的排序方式来解决这个问题。