1. /*
   
2. 对字符串中字符进行自然顺序排序。
   
3. 
   
4. 思路：
   
5. 1，字符串变成字符数组。
   
6. 2，对数组排序，选择，冒泡，Arrays.sort();
   
7. 3，将排序后的数组变成字符串。
   
8. 
   
9. "vcz1bdAa+cs"-->abccdsvz
   
10. */
    
11. import java.util.*;
    
12. 
    
13. class  Demo
    
14. {
    
15.         public static void sop(Object obj)
    
16.         {
    
17.                 System.out.println(obj);
    
18.         }
    
19. 
    
20.         public static void main(String[] args)
    
21.         {
    
22.                 String s = "vcz1bdAa+cs";
    
23.                 s = toSort(s);
    
24.                 sop(s);
    
25.         }
    
26. 
    
27.         public static String toSort(String s)
    
28.         {
    
29.                 //将字符串变成字符数组
    
30.                 char[] chr = new char[s.length()];
    
31.                 chr = s.toCharArray();
    
32.                 //对字符数组进行排序，使用选择排序。排序过程中判断字符是否是小写a-z之间的字符，如果不是，不排序，
    
33.                 sort(chr);                                         //<font color="#ff0000">这个地方，明明已经把小写的a-z选出来排序过了，为什么转成字符串后还是原来的字符串呢？为什么为什么啊？</font>
    
34.                 //将排序后的数组变成字符串。
    
35.                 return String.valueOf(chr);
    
36.         }
    
37. 
    
38.         //对数组进行排序
    
39.         public static void sort(char[] chr)
    
40.         {
    
41.                 chr = clear(chr);
    
42.                 for(int x = 0;x<chr.length;x++)
    
43.                 {
    
44.                                 for(int y = x+1;y<chr.length;y++)
    
45.                                 {
    
46.                                         if(chr[x]>chr[y])
    
47.                                                 location(chr,x,y);
    
48.                                 }
    
49.                 }
    
50.         }
    
51.         //获取小写a-z的字符
    
52.         public static char[] clear(char[] chr)
    
53.         {
    
54.                 StringBuilder sb = new StringBuilder();
    
55.                 for(int x = 0;x<chr.length;x++)
    
56.                 {
    
57.                         if((chr[x]>='a' && chr[x]<='z'))
    
58.                                 sb.append(chr[x]);
    
59.                 }
    
60.                 String s = sb.toString();
    
61.                 return s.toCharArray();
    
62.         }
    
63.         //换位动作。
    
64.         public static void location(char[] chr,int x,int y)
    
65.         {
    
66.                 char temp = chr[x];
    
67.                 chr[x] = chr[y];
    
68.                 chr[y] = temp;
    
69.         }
    
70. }

复制代码

晕，问题在33行 font color标签内，，，，

我自己又看了几遍，发现，在第41行，chr = clear(chr);，，，这句话字符数组类型变量chr已经重新指向了一个新的数组，所以下面的for运算，运算的是新的数组中的内容，跟原引用毛联系都没有，真蛋疼，，，，，，，解决办法就是，别在排序里获取小写的a-z字符了，直接先获取完，把获取到的结果传给排序的函数，，，，，，，，，，，，

这是毕老师留的一个练习题目，修改完后的代码如下，感觉这块不是太熟悉，实现方法肯定有很多种，一会再发个帖子看看其他哥们都是怎样实现的。事实证明，东西是学到了，但是学习后没有进行总结，所以到用的时候不知道怎么用了，，，总结很重要，否则会很蛋疼。。。。。。现在就滚去写总结去。。。。。。：

1. import java.util.*;
   
2. 
   
3. class  Demo
   
4. {
   
5.         public static void sop(Object obj)
   
6.         {
   
7.                 System.out.println(obj);
   
8.         }
   
9. 
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 String s = "vcz1bdAa+cs";
    
13.                 s = toSort(s);
    
14.                 sop(s);
    
15.         }
    
16.        
    
17. 
    
18. 
    
19.         public static String toSort(String s)
    
20.         {
    
21.                         //将字符串变成字符数组
    
22.                         char[] chr = new char[s.length()];
    
23.                         chr = s.toCharArray();
    
24.                         //对字符数组进行排序，使用选择排序。排序过程中判断字符是否是小写a-z之间的字符，如果不是，不排序，
    
25.                         chr = clear(chr);
    
26.                         sort(chr);
    
27.                         //将数组变成字符串返回去。
    
28.                         return String.valueOf(chr);
    
29.         }
    
30. 
    
31.         //对数组进行排序
    
32.         public static void sort(char[] chr)
    
33.         {
    
34.                 for(int x = 0;x<chr.length;x++)
    
35.                 {
    
36.                         for(int y = x+1;y<chr.length;y++)
    
37.                         {
    
38.                                         if(chr[x]>chr[y])
    
39.                                                         location(chr,x,y);
    
40.                         }
    
41.                 }
    
42.         }
    
43.        
    
44.         //换位动作，确实做了，而且操作了数组中的元素，被数组记录了下来。
    
45.         public static void location(char[] chr,int x,int y)
    
46.         {
    
47.                         char temp = chr[x];
    
48.                         chr[x] = chr[y];
    
49.                         chr[y] = temp;
    
50.         }
    
51.         public static char[] clear(char[] chr)
    
52.         {
    
53.                         StringBuilder sb = new StringBuilder();
    
54.                         for(int x = 0;x<chr.length;x++)
    
55.                         {
    
56.                                         if((chr[x]>='a' && chr[x]<='z'))
    
57.                                                         sb.append(chr[x]);
    
58.                         }
    
59.                         String s = sb.toString();
    
60.                         return s.toCharArray();
    
61.         }
    
62. }

复制代码

或者有哥们还在看这个帖子的话，告诉我你有几种实现的方法，哪一种好些？？

题目：
/*
对字符串中字符进行自然顺序排序。

思路：
1，字符串变成字符数组。
2，对数组排序，选择，冒泡，Arrays.sort();
3，将排序后的数组变成字符串。

"vcz1bdAa+cs"-->abccdsvz
*/

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢