A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 何堂红 中级黑马   /  2014-5-31 00:06  /  2512 人查看  /  10 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 何堂红 于 2014-6-1 00:23 编辑

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

  2. import java.util.ArrayList;
  3. import java.util.Comparator;
  4. import java.util.List;
  5. import java.util.TreeSet;

  6. public class test03 {

  7.         /**
  8.          * @param args
  9.          *            在一个集合中存储了无序并且重复的字符串,定义一个方法,使其有序,并且不能去除重复、
  10.          */
  11.         public static void main(String[] args) {

  12.                 // 由于是重复的字符串,所以只能是list集合,而不是set集合。
  13.                 List<String> list = new ArrayList<String>();
  14.                 list.add("b");
  15.                 list.add("a");
  16.                 list.add("a");
  17.                 list.add("d");
  18.                 list.add("a");
  19.                 list.add("d");
  20.                 list.add("a");
  21.                 list.add("c");
  22.                 list.add("c");
  23.                 list.add("c");

  24.                 // 查看原始输入数据
  25.                 System.out.println(list);

  26.                 // 调用mysort()方法,排序并且不删除重复字符。
  27.                 mysort(list);

  28.                 // 查看结果
  29.                 System.out.println(list);

  30.         }

  31.         public static void mysort(List<String> list) {
  32.                 // 创建TreeSet对象,因为要排序,所以创建TreeSet对象
  33.                 TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {// 比较器,匿名内部类
  34.                                         // 重写 compare方法
  35.                                         @Override
  36.                                         public int compare(String s1, String s2) {
  37.                                                 int num = s1.compareTo(s2);
  38.                                                 return num == 0 ? 1 : num; // 如果是s1和s2相同,也对对象进行存储
  39.                                         }
  40.                                 });

  41.                 // 将list集合添加到ts集合,并且利用TreeSet自己的比较器,进行排序
  42.                 ts.addAll(list);

  43.                 // 清空list 集合,以便于重新接收元素
  44.                 list.clear();
  45.                 // 重新接收有序的元素
  46.                 list.addAll(ts);
  47.         }
复制代码

评分

参与人数 1技术分 +1 收起 理由
zzkang0206 + 1 神马都是浮云

查看全部评分

10 个回复

倒序浏览
我自己尝试了半天,还是不行,请各位帮我重写一下,最好顺便能指出我的问题或者给出一些建议,或者列出一些知识点也行,谢谢了!
回复 使用道具 举报 1 0
本帖最后由 饥渴ing 于 2014-5-31 00:44 编辑

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技术分 +1 收起 理由
zzkang0206 + 1 赞一个!

查看全部评分

回复 使用道具 举报 1 0
  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技术分 +1 收起 理由
zzkang0206 + 1 赞一个!

查看全部评分

回复 使用道具 举报
  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. *                 内部类实现对接口Comparator的compareTo方法的实现。
  10. *  匿名内部类的基本格式:
  11. *          new  外部(其它)类名或者接口名(){
  12. *              重写父类或者接口的抽象方法,也可以定义特有方法
  13. *               };
  14. *      另外: TreeSet<String> ts = new TreeSet<>(new Comparator<String>())这是通过
  15. *      TreeSet的构造方法进行创建的对象,源程序中只是将这两个部分整合在了一起。
  16. *           匿名内部类就是建立了一个带有内容的外部类或者接口的子类匿名对象。
  17. *           
  18. *        建议:楼主的学习的过程中,首先掌握基本的定义格式,然后实现匿名内部类和普通类之间的互转,
  19. *                了解两者之间的不同、应用场景等。然后在理解的基础上,对代码进行优化,相信你一定会取得
  20. *                很大的进步,加油!
  21. */
  22. public class Test_TreeSetSort {

  23.         public static void main(String[] args) {
  24.                 List<String> list = new ArrayList<String>();
  25.                 list.add("b");
  26.                 list.add("a");
  27.                 list.add("a");
  28.                 list.add("d");
  29.                 list.add("a");
  30.                 list.add("d");
  31.                 list.add("a");
  32.                 list.add("c");
  33.                 list.add("c");
  34.                 list.add("c");

  35.                 // 查看原始输入数据
  36.                 System.out.println(list);
  37.                 //调用mySort方法,排序并且不删除重复字符
  38.                 mySort(list);
  39.                 //查看结果
  40.                 System.out.println(list);

  41.         }
  42.        
  43.         public static void mySort(List<String> list) {
  44.                 //通过TreeSet集合创建ts对象,调用自己创建的构造器
  45.                 TreeSet<String> ts = new TreeSet<>(new CompareBySort());
  46.                 ts.addAll(list);
  47.                 list.clear();
  48.                 list.addAll(ts);
  49.         }
  50. }

  51. //创建CompareBuSort类是实现接口Comparable,从而定义自己所需的构造器
  52. class CompareBySort implements Comparator<String> {

  53.         @Override
  54.         public int compare(String s1, String s2) {
  55.                 int num = s1.compareTo(s2);
  56.                 return num == 0 ? 1 : num;
  57.         }
  58. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
zzkang0206 + 1 赞一个!

查看全部评分

回复 使用道具 举报
受教了
回复 使用道具 举报
More 中级黑马 2014-5-31 06:23:33
7#
都是大神啊
回复 使用道具 举报
饥渴ing 发表于 2014-5-31 00:39
Set的值是唯一的.你使用TreeSet无法实现重复元素排序的.
排序可以使用冒泡排序法.
String本身实现了compara ...

嗯,谢谢
回复 使用道具 举报
回复 使用道具 举报
学习学习....
回复 使用道具 举报

嗯,谢谢,对这个答案我太满意了,如果打分的话,我要给你打满分100分。太感谢了!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马