我现在有一个字符串"23 98 71 54 60”请你想办法，
把这个字符串变成如下字符串：“23 54 60 71 98“。

学习一下

看集合框架那一块

用空格切割的到字符串数组，字符串数组转成int数组，排序，int数组拼接。

Dark县令 发表于 2015-3-28 23:59
就是用for排序就行了

这是字符串不是int型数据

1.用空格将字符串分割split(" ")切割成字符串数组   2.对数组进行排序  3. 将数组转换成字符串输出，代码我就不帮你实现了哈

这个排序就可以了啊

看毕老师的视频API中的基本数据类型对象包装类练习…

自己的一点想法，基本和楼上一致。

1. 
   
2. /*
   
3. 需求：
   
4. 有一个字符串
   
5. 请你想办法，把这个字符串变成如下字符串：“23 54 60 71 98“。
   
6. 
   
7. 思路：1.定义字符串存放目标字符串；
   
8. 2.以空格切割字符串并转存为int型数组；
   
9. 3.排序
   
10. 4.将排列好的数字再转存为字符串
    
11. 5.将字符串调整为要求的格式
    
12. */
    
13. 
    
14. class  StringToInt
    
15. {
    
16.         public static void main(String[] args)
    
17.         {
    
18.                 String s = "23 98 71 54 60";//定义s存放原字符串
    
19.                
    
20.                 String[] arrS = new String[5];//定义字符数组，存放切割之后的字符串
    
21.                 arrS = s.split(" ");//切割字符串，存储在字符串数组中
    
22. 
    
23.                 int[] arr = new int[5];//定义int型数组
    
24.                
    
25.                 //将切割后的字符串转化成数字
    
26.                 for (int i=0;i<5 ;i++ )
    
27.                 {
    
28.                         arr[i] = Integer.parseInt(arrS[i]);
    
29.                 }
    
30.                 //输出转化后的数字
    
31.                 for (int i=0;i<arrS.length ;i++ )
    
32.                 {
    
33.                         System.out.println(arr[i]);
    
34.                 }
    
35.                 System.out.println("---------------");
    
36. 
    
37.                 //对切割后的数字排序,for循环嵌套
    
38.                 for(int i=0;i<arr.length;i++)
    
39.                 {
    
40.                         for (int j=0;j<arr.length ;j++ )
    
41.                         {
    
42.                                 if (arr[i]<arr[j])
    
43.                                 {
    
44.                                         int temp = arr[i];
    
45.                                         arr[i] = arr[j];
    
46.                                         arr[j] = temp;
    
47.                                 }
    
48.                         }
    
49.                        
    
50.                 }
    
51.                 //输出排序后的数字
    
52.                 for (int i=0;i<arr.length;i++ )
    
53.                 {
    
54.                         System.out.println(arr[i]);
    
55.                 }
    
56. 
    
57. 
    
58.                 //创建字符串缓冲区
    
59.                 StringBuffer sb = new StringBuffer();
    
60.                 //将排好序的数字加入到缓冲区
    
61.                 for (int i=0;i<arr.length;i++ )
    
62.                 {
    
63.                         if(i==0||i==arr.length-1)
    
64.                                 sb.append(arr[i]);
    
65.                         else
    
66.                                 sb.append(" "+arr[i]+" ");
    
67. 
    
68.                 }
    
69.                 //将缓冲区的字符串存入字符串变量
    
70.                 String s1 = new String(sb.toString());
    
71.                 System.out.println("---------------");
    
72.                 System.out.println(s1);
    
73. 
    
74.         }
    
75. }
    

复制代码

希望对你有用~~

public class Test {

        public static void main(String[] args) {
                String string = "23 98 71 54 60";
                String[] data = string.split(" ");
                int[] num = new int[data.length];
                for (int i = 0; i < num.length; i++) {
                        num[i] = Integer.parseInt(data[i]);
                }
                Arrays.sort(num);
                StringBuilder builder = new StringBuilder();
                for (int i = 0; i < num.length; i++) {

                        if (i != num.length - 1) {
                                builder.append(String.valueOf(num[i]) + " ");
                        } else {
                                builder.append(String.valueOf(num[i]));
                        }
                }
                System.out.println(builder.toString());
        }

}

可能写的比较复杂

/*
* 思路： 1.将字符串分割，存放入整形数组中
*     2.将整型数组仅进项排序
*     3将排序后的数组加入空格重新组合，
*     4，去除多余的空格
* */
class   sort
{
        public static void main(String[] args)
        {
                String s="23 98 71 54 60"; //将原来字符串存入到string中
                String[] s1=new String[5];//创建一个字符型数组用于存储切割后的字符串
                s1=s.split(" ");//将字符串切割，存储在字符串数组中
                int[] arr=new int[5];  //创建一个整形数组存储整形数据
               
                 for(int i=0;i<5;i++)
                {arr[i]=Integer.parseInt(s1[i]);}//用循环将每个字符串转换成整形数据，存入整形数组中
sort(arr);//调用静态方法将整型数组排序
StringBuffer sb=new StringBuffer();//创建一个缓冲字符串
for(int i=0;i<5;i++)   //将排序后的数组存入到缓冲字符串中，每个变量后加空格隔开
                {sb.append(arr[i]+" ");   }
String s2=new String(sb.toString()); //将缓冲字符串中的数据存入一个字符串变量中
String s3=s2.trim();//将字符内的边界的空格去除

System.out.print(s3); //输出结果
        }
        //将传入的数组进行排序
public static void sort(int[] arr){
        int temp;
        for(int i=0;i<5;i++)
        {for(int j=0;j<5;j++)
        {if(arr[i]>arr[j]){
        temp=arr[i];
        arr[i]=arr[j];
                arr[j]=temp;
        }
        }
        }
}
}

。。。就是排序嘛。。。以空格切割完，再进行排序。。。

用空格切割以后会返回一个String数组，遍历转成integer类型进行排序就可以了

就是用for排序就行了

就是排序.

以空格切割 然后变成int 排序 然后拼在一起就行