7.编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符
原始字符串是"abc"，打印得到下列所有组合情况：
                "a" "b" "c"
                "ab" "bc" "ca" "ba" "cb" "ac"
                "abc" "acb" "bac" "bca" "cab" "cba"

我写的时候考虑的是 1.每行字符个数都是递增 2.下一行的字符是建立在上一行的基础上得到的 ，所以在第一行的基础上一次获取第二行第三行...
每行获取之后需要与给定的字符串进行组合，排除重复，然后存储到新集合中，返回新集合即可。
我的代码如下：

1. import java.util.*;
   
2. 
   
3. 
   
4. class Test7 {
   
5.         
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 //调用获取子串的方法
   
9.                 getSubString("abcd");
   
10.         }
    
11.         
    
12.         //用于获取所有可能子串的方法
    
13.         public static void getSubString(String str)
    
14.         {
    
15.                 //将字符串转成字符数组
    
16.                 char[] ch = str.toCharArray();
    
17.                
    
18.                 //创建一个List集合用于存放字符串集合
    
19.                 ArrayList<String> arr = new ArrayList<String>();
    
20.                
    
21.                 //将{a,b,c}先行存入到集合中用于第二，第三行获取
    
22.                 for(int x=0;x<ch.length;x++)
    
23.                 {
    
24.                         arr.add(ch[x]+"");
    
25.                 }
    
26.                
    
27.                 //有多少字符就有多少行，循环获取每行子串
    
28.                 for(int x=0;x<str.length();x++)
    
29.                 {
    
30.                         //调用getList方法获取每行的子串可能，注意第一行判断
    
31.                         if(x!=0)
    
32.                                 arr = getList(arr,ch);
    
33.                         
    
34.                         //利用高级for循环获取集合中元素，也可以用迭代器获取
    
35.                         for(String s:arr)
    
36.                         {
    
37.                                  System.out.print("\"" + s + "\" ");
    
38.                         }
    
39.                          System.out.println();
    
40.                 }
    
41.         }
    
42.         
    
43.         //获取子串可能性的方法
    
44.         public static ArrayList<String> getList(ArrayList<String> arr,char[] ch)
    
45.         {
    
46.                 //新建一个新的集合用于存放新的一行用于返回
    
47.                 ArrayList<String> newarr = new ArrayList<String>();
    
48.                
    
49.                 //对上一行元素进行循环，来得到新的不重复的子串
    
50.                 for(String s:arr)
    
51.                 {
    
52.                         String str = s;
    
53.                         //对字符数组中元素进行遍历，如果当前字符串中不含有该元素就将str+ch[i]加入到新的集合中
    
54.                         for(int i=0;i<ch.length;i++)
    
55.                         {
    
56.                                 if(str.indexOf(ch[i]) == -1)
    
57.                      {
    
58.                              newarr.add(str + ch[i]);
    
59.                       }
    
60.                         }
    
61.                         
    
62.                 }
    
63.                 //返回新的集合
    
64.                 return newarr;
    
65.         }
    
66. }

复制代码

写完之后看到论坛上有前辈给出的写法是在元素组合部分采用了两重循环同时getList带的参数也多一个，我个人觉得那个循环多余，只需要获取上一行元素对应的List，再用List中元素组合ch中字符就能得到新的一行的List，所以觉得他写的是多余的，我验证结果是相同的，但是也不懂为什么他的也能行，有没有大神能分辨一下？
他的代码如下：

1. //取得每一行要输出的list集合
   
2.         public static ArrayList<String> getList(ArrayList<String> list,int len,char[] ch){
   
3.                 //newList 用来装下一行要遍历的元素，list则代表上一行的元素集合
   
4.                 ArrayList<String> newList  = new ArrayList<String>();
   
5.         
   
6.                 //该循环用来取得上一行的元素
   
7.                 for(String s:list){
   
8.                         String str = s;        
   
9.                                 
   
10.                                 for(int j = str.length();j < len ;j++){
    
11.                                         //遍历字符串中没个元素
    
12.                                         for(int i = 0; i < ch.length; i++){
    
13.                                                 //字符不重复则将Str+ch[i]添加进集合，
    
14.                                                 if(str.indexOf(ch[i]) == -1){
    
15.                                                         newList.add(str + ch[i]);
    
16.                                                 }
    
17.                                         }
    
18.                                 }
    
19.                                 
    
20.                 }
    
21.                
    
22.                 return newList.size() == 0 ? list:newList;
    
23.         }

复制代码

那位前辈的代码确实是多余了，多余的语句是for(int j = str.length();j < len ;j++) 因为上一行和新一行的长度只差1，内循环就执行一次，没必要搞一个外循环，他这样写了循环也还只是执行一次。不过，也正因为他的 for(int j = str.length();j < len ;j++)是多余而不是错误，所以他仍然得到了正确结果

我基础测试也碰到这题了，想了很久都没想出来。他的第一层for循环体中就没有用到参数  j，他只是重复运行多次，如果第一层for循环走1次以上，newList中就会有重复的元素，打印出来肯定是错误的，肯定是他传的len参数刚好等于(str.length()+1),循环走一次就跳出来了，至于最后一句 return newList.size() == 0 ? list:newList;我是看不懂，难道是担心给定的字符串中有相同的字符，

兄弟，加油，一起考进黑马

shuren2015 发表于 2015-2-27 16:49
兄弟，加油，一起考进黑马

一起加油。

shuren2015 发表于 2015-2-27 16:48
我基础测试也碰到这题了，想了很久都没想出来。他的第一层for循环体中就没有用到参数  j，他只是重复运行多 ...

不是，return newList.size() == 0 ? list:newList;其实就是为了返回第一行{a，b，c}元素，当走到它写的那个多余的循环时，如果没有这句，那第一行的元素就返回不了，所以用要判断是否是返回第一行的List，是就直接返回那个循环等于没走，不是就返回新的List。

1. package com.itheima;
   
2. 
   
3. /**
   
4. * 第7题：编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
   
5. *                 原始字符串是"abc"，打印得到下列所有组合情况：
   
6. *                 "a" "b" "c"
   
7. *                 "ab" "bc" "ca" "ba" "cb" "ac"
   
8. *           "abc" "acb" "bac" "bca" "cab" "cba"
   
9. *   
   
10. * */
    
11. 
    
12. public class Test7 {
    
13. 
    
14.         public static void main(String[] args) {
    
15.                 //字符串abc
    
16.                 String str = "abc";
    
17.                 //字符串转换为字符数组
    
18.                 char[] array = str.toCharArray();
    
19.                 //功能实现函数
    
20.                 fun(array);
    
21.         }
    
22.        
    
23.         public static void fun(char[] src){
    
24.                 //打印"a" "b" "c"
    
25.                 for (int i = 0; i < src.length; i++) {
    
26.                         System.out.print(src[i]+" ");
    
27.                 }
    
28.                 //换行
    
29.                 System.out.println();
    
30.                 //打印"ab" "bc" "ca" "ba" "cb" "ac"
    
31.                 for (int i = 0; i < src.length; i++) {
    
32.                         for (int j = 0; j < src.length; j++) {
    
33.                                 //判断去重复
    
34.                                 if(src[i]==src[j]){
    
35.                                         continue;
    
36.                                 }
    
37.                                 System.out.print(src[i]+""+src[j]+" ");
    
38.                         }
    
39.                 }
    
40.                 //换行
    
41.                 System.out.println();
    
42.                 //打印"abc" "acb" "bac" "bca" "cab" "cba"
    
43.                 for (int i = 0; i < src.length; i++) {
    
44.                         for (int j = 0; j < src.length; j++) {
    
45.                                 for (int j2 = 0; j2 < src.length; j2++) {
    
46.                                         //判断去重复
    
47.                                         if((src[i]==src[j])||(src[i]==src[j2])||(src[j]==src[j2])){
    
48.                                                 continue;
    
49.                                         }
    
50.                                         System.out.print(src[i]+""+src[j]+""+src[j2]+" ");
    
51.                                 }
    
52.                         }
    
53.                 }
    
54.         }
    
55. }

复制代码

当时做这道题时，我的思路第一步，字符串变字符数组（因为键盘输入为字符串），第二步：找规律，循环输出是最简便也最快捷的。第三步：去重复，本想写一个去重复函数，但后来发现这样不但增加代码量，而且随着字母组合的复杂还有不但添加代码，于是放弃而采用if直接判断---方便简洁。第四步：分布分功能调试程序，只要思路清晰了，问题也就解决了。个人水平有限，希望大家多多给予指导

哎哎~~感觉看起来好难额