对给定字符串中的数值进行从小到大排序后，生成一个有序的数值的字符串。
如把"34 9 -1 88 2 64" 变成 "-1 2 9 34 64 88"
说说思路吧

将字符串变成数组，对数组排序，再转换成字符串。

ls的，具体写写呗

要得出这个结果而已是吗？没有说要特定什么类吧？
那这样就好了

1. import java.util.*;
   
2. 
   
3. class  StringDemo
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 String s = "34 9 -1 88 2 64";
   
8.                 String [] ss = s.split(" ");
   
9.                 int [] a =  new int[6];
   
10. 
    
11. 
    
12.                 for(int i = 0;i<ss.length;i++){
    
13.                         a[i] = Integer.parseInt(ss[i]);
    
14.                 }
    
15. 
    
16.                 Arrays.sort(a);
    
17.                 StringBuffer sb = new StringBuffer ();
    
18. 
    
19.                 for(int i = 0;i < a.length;i++){
    
20.                         sb.append(a[i]+" ");
    
21.                 }
    
22. 
    
23.                 s = sb.toString();       
    
24.                 System.out.println(s);
    
25. 
    
26.         }
    
27. }
    

复制代码

思路看前面：

import java.util.*;
class Test{       
        public static void main(String args[]) {
    String s="34 9 -1 88 2 64" ;
        String[] temp=s.split(" ");
        int len=temp.length;
        int[] n=new int[len];
        for(int i=0;i<len;i++)
                n[i]=Integer.parseInt(temp[i]);
        Arrays.sort(n);
        s="";
        for(int n1:n)
                s+=n1+" ";
        System.out.print(s);
    }
}

还可以这样，用TreeSet，再重写compare 方法：

1. import java.util.*;
   
2. class Test{       
   
3.         public static void main(String args[]) {
   
4.     String s="34 9 -1 88 2 64" ;
   
5.         String[] temp=s.split(" ");
   
6.         Set<String> ts=new TreeSet<String>(new myComparator());
   
7.         for(String t:temp)
   
8.                 ts.add(t);
   
9.         // s=ts.toString();
   
10.         System.out.print(ts);
    
11.     }
    
12. }
    
13. 
    
14. class myComparator implements Comparator<String> {
    
15.     public int compare(String o1, String o2) {
    
16.         return Integer.parseInt(o1)-Integer.parseInt(o2);
    
17.     }
    
18. }

复制代码

黄秋 发表于 2012-1-16 04:52
还可以这样，用TreeSet，再重写compare 方法：

我觉得用TreeSet用于int数组排序好像不是很妥
TreeSet底层是二叉树，其实是二叉排序数，每次排序是调用二叉树的中序遍历。
虽说是排序，但是理念不是很相同，一个是在存储结构中先排好，另一个是直接对其数组排序

搞这么复杂干嘛，还这个类那个类的。直接数组出来，转化一下，冒泡排序，选择排序，2分排序随便搞一下就出来了。

ls聪明！

用冒泡排序或者选择排序升序排列就行了呀...

刘明瑞 发表于 2012-1-16 12:46
搞这么复杂干嘛，还这个类那个类的。直接数组出来，转化一下，冒泡排序，选择排序，2分排序随便搞一下就出 ...

数组排序的，我也写了，用TreeSet，再重写compare，是高级类型的常用办法，志在学习，也是一题多解呀。

我觉得可以用比较器进行比较，先把String字符串转成char[]数组，再把char[]转成arraylist，因为是字符比较可以用系统自带的比较collections.sort（）方法进行简单比较，方法已经实现，现把代码贴在下面:
String b = "34 9 -1 88 2 64";
                char[] a = b.toCharArray();
                List<Character> list = new ArrayList<Character>();
                for(int i=0 ;i< a.length;i++){
                        list.add(a[i]);
                        System.out.println(a[i]);
                }
                Collections.sort(list);
                for(char i:list){
                        System.out.println(i);
                }

沈样 发表于 2012-1-19 19:15
我觉得可以用比较器进行比较，先把String字符串转成char[]数组，再把char[]转成arraylist，因为是字符比较 ...

你的程序，自己运行过吗？char[]只能进行一位数的比较。这比较要变为整数才好处理，我重写你的代码，改了不少，测试过：

1. public class Test {
   
2.         public static void main(String[] args) {
   
3.                 String b = "34 9 -1 88 2 64";
   
4.                 String[] a = b.split(" ");
   
5.                 List<Integer> list = new ArrayList<Integer>();
   
6.                 for(int i=0 ;i< a.length;i++){
   
7.                                 list.add(Integer.parseInt(a[i]));
   
8.                                 System.out.println(a[i]);
   
9.                 }
   
10.                 Collections.sort(list);
    
11.                 for(int i:list){
    
12.                                 System.out.println(i);
    
13.                 }
    
14.         }
    
15. }

复制代码

已解决，多谢