下面这段代码中，mysort方法是通过匿名内部类实现的，请不要使用匿名内部类重新将它实现（我已经被它搞晕了，只好求助

1. package test;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Comparator;
   
5. import java.util.List;
   
6. import java.util.TreeSet;
   
7. 
   
8. public class test03 {
   
9. 
   
10.         /**
    
11.          * @param args
    
12.          *            在一个集合中存储了无序并且重复的字符串，定义一个方法，使其有序，并且不能去除重复、
    
13.          */
    
14.         public static void main(String[] args) {
    
15. 
    
16.                 // 由于是重复的字符串，所以只能是list集合，而不是set集合。
    
17.                 List<String> list = new ArrayList<String>();
    
18.                 list.add("b");
    
19.                 list.add("a");
    
20.                 list.add("a");
    
21.                 list.add("d");
    
22.                 list.add("a");
    
23.                 list.add("d");
    
24.                 list.add("a");
    
25.                 list.add("c");
    
26.                 list.add("c");
    
27.                 list.add("c");
    
28. 
    
29.                 // 查看原始输入数据
    
30.                 System.out.println(list);
    
31. 
    
32.                 // 调用mysort()方法，排序并且不删除重复字符。
    
33.                 mysort(list);
    
34. 
    
35.                 // 查看结果
    
36.                 System.out.println(list);
    
37. 
    
38.         }
    
39. 
    
40.         public static void mysort(List<String> list) {
    
41.                 // 创建TreeSet对象，因为要排序，所以创建TreeSet对象
    
42.                 TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {// 比较器，匿名内部类
    
43.                                         // 重写 compare方法
    
44.                                         @Override
    
45.                                         public int compare(String s1, String s2) {
    
46.                                                 int num = s1.compareTo(s2);
    
47.                                                 return num == 0 ? 1 : num; // 如果是s1和s2相同，也对对象进行存储
    
48.                                         }
    
49.                                 });
    
50. 
    
51.                 // 将list集合添加到ts集合，并且利用TreeSet自己的比较器，进行排序
    
52.                 ts.addAll(list);
    
53. 
    
54.                 // 清空list 集合，以便于重新接收元素
    
55.                 list.clear();
    
56.                 // 重新接收有序的元素
    
57.                 list.addAll(ts);
    
58.         }

复制代码

）

我自己尝试了半天，还是不行，请各位帮我重写一下，最好顺便能指出我的问题或者给出一些建议，或者列出一些知识点也行，谢谢了！

Set的值是唯一的.你使用TreeSet无法实现重复元素排序的.
排序可以使用冒泡排序法.
String本身实现了comparable接口可以直接用compareTo方法.

  public static void mysort(List<String> list) {
                 StringBuilder temp = new StringBuilder();
                 for (int i = 0; i < list.size(); i++) {  
                         for (int j = i; j < list.size(); j++) {
                                 if ((list.get(i)).compareTo(list.get(j)) > 0) {
                                         //清空temp
                                         temp.delete(0, sb.length());
                                          //交换元素
                                         temp.append(list.get(i));
                                         list.set(i, list.get(j));
                                         list.set(j, sb.toString());
                                 }
                         }
                 }
         }
如果要实现任意对象排序可以参考Collections的sort方法
public static <T extends Comparable<? super T>> void sort(List<T> list)
//T必须实现了Comparable接口.Comparable的元素必须是T的父类或T本身

1. import java.util.*;
   
2. public class Demo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 List<String> list = new ArrayList<String>();
   
7.                 list.add("b");
   
8.                 list.add("a");
   
9.                 list.add("a");
   
10.                 list.add("d");
    
11.                 list.add("a");
    
12.                 list.add("d");
    
13.                 list.add("a");
    
14.                 list.add("c");
    
15.                 list.add("c");
    
16.                 list.add("c");
    
17.                 System.out.println(list);
    
18.                 mysort(list);
    
19.                 System.out.println(list);
    
20.         }
    
21.         /*
    
22.         static void mysort(List<String> list)//使用集合工具类
    
23.         {
    
24.                 Collections.sort(list);
    
25.         }
    
26.         */
    
27.         static void mysort(List<String> list)//使用数组工具类
    
28.         {
    
29.                 String[] arr = list.toArray(new String[list.size()]);
    
30.                 Arrays.sort(arr);
    
31.                 list = Arrays.asList(arr);
    
32.         }
    
33. }
    
34. //存储可重复元素的集合只有List，Set不能存储重复的元素。

复制代码

1. import java.util.ArrayList;
   
2. import java.util.Comparator;
   
3. import java.util.List;
   
4. import java.util.TreeSet;
   
5. 
   
6. /*
   
7. * 在一个集合中存储了无序并且重复的字符串，定义一个方法，使其有序，并且不能去除重复
   
8. *
   
9. * 分析：关于楼主的困扰：主要是对匿名内部类的不熟悉，其实在楼主的源程序中是通过匿名
   
10. *                 内部类实现对接口Comparator的compareTo方法的实现。
    
11. *  匿名内部类的基本格式：
    
12. *          new  外部（其它）类名或者接口名（）{
    
13. *              重写父类或者接口的抽象方法，也可以定义特有方法
    
14. *               }；
    
15. *      另外： TreeSet<String> ts = new TreeSet<>(new Comparator<String>())这是通过
    
16. *      TreeSet的构造方法进行创建的对象，源程序中只是将这两个部分整合在了一起。
    
17. *           匿名内部类就是建立了一个带有内容的外部类或者接口的子类匿名对象。
    
18. *           
    
19. *        建议：楼主的学习的过程中，首先掌握基本的定义格式，然后实现匿名内部类和普通类之间的互转，
    
20. *                了解两者之间的不同、应用场景等。然后在理解的基础上，对代码进行优化，相信你一定会取得
    
21. *                很大的进步，加油！
    
22. */
    
23. public class Test_TreeSetSort {
    
24. 
    
25.         public static void main(String[] args) {
    
26.                 List<String> list = new ArrayList<String>();
    
27.                 list.add("b");
    
28.                 list.add("a");
    
29.                 list.add("a");
    
30.                 list.add("d");
    
31.                 list.add("a");
    
32.                 list.add("d");
    
33.                 list.add("a");
    
34.                 list.add("c");
    
35.                 list.add("c");
    
36.                 list.add("c");
    
37. 
    
38.                 // 查看原始输入数据
    
39.                 System.out.println(list);
    
40.                 //调用mySort方法，排序并且不删除重复字符
    
41.                 mySort(list);
    
42.                 //查看结果
    
43.                 System.out.println(list);
    
44. 
    
45.         }
    
46.        
    
47.         public static void mySort(List<String> list) {
    
48.                 //通过TreeSet集合创建ts对象，调用自己创建的构造器
    
49.                 TreeSet<String> ts = new TreeSet<>(new CompareBySort());
    
50.                 ts.addAll(list);
    
51.                 list.clear();
    
52.                 list.addAll(ts);
    
53.         }
    
54. }
    
55. 
    
56. //创建CompareBuSort类是实现接口Comparable，从而定义自己所需的构造器
    
57. class CompareBySort implements Comparator<String> {
    
58. 
    
59.         @Override
    
60.         public int compare(String s1, String s2) {
    
61.                 int num = s1.compareTo(s2);
    
62.                 return num == 0 ? 1 : num;
    
63.         }
    
64. }

复制代码

受教了

都是大神啊

饥渴ing 发表于 2014-5-31 00:39
Set的值是唯一的.你使用TreeSet无法实现重复元素排序的.
排序可以使用冒泡排序法.
String本身实现了compara ...

嗯，谢谢

谢振宣 发表于 2014-5-31 01:06

嗯，受教了

学习学习....

hamiguadjs 发表于 2014-5-31 01:09

嗯，谢谢，对这个答案我太满意了，如果打分的话，我要给你打满分100分。太感谢了！