1. package com.itheima;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. public class Test7 {
   
6. 
   
7.         /**
   
8.          * 7、编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如： 原始字符串是"abc"，打印得到下列所有组合情况： "a" "b"
   
9.          * "c" "ab" "bc" "ca" "ba" "cb" "ac" "abc" "acb" "bac" "bca" "cab" "cba"
   
10.          *
    
11.          * 思路：1，将字符串拆分为单个字符 2，使用递归算法进行组合
    
12.          *
    
13.          */
    
14.         public static void main(String[] args) {
    
15.                 // System.out.println("请输入所要转换的字母或单词！");
    
16.                 // //定义并初始化键盘读入语句
    
17.                 // Scanner sc = new Scanner(System.in);
    
18.                 // //声明字符串接收从键盘读取的字符串
    
19.                 // String str = sc.nextLine();
    
20.                 print("sah");
    
21.         }
    
22. 
    
23.         public static void print(String str) {
    
24.                 int x = str.length();
    
25.                 String[] ch1 = new String[x];
    
26.                 String[] ch2 = new String[x];
    
27.                 for (int i = 0; i < str.length(); i++) {
    
28.                         ch1[i] = str.substring(i, i + 1);
    
29.                         ch2[i] = str.substring(i, i + 1);
    
30.                 }
    
31.                 myout(ch1, ch2);
    
32.         }
    
33. 
    
34.         public static void myout(String[] ch1, String[] ch2) {
    
35.                 StringBuffer sbf = new StringBuffer();
    
36.                 String[] ch3 = null;
    
37.                 int k = 1;
    
38.                 k++;
    
39.                 for (int i = 0; i < ch1.length; i++) {
    
40.                         for (int j = 0; j < ch2.length; j++) {
    
41.                                 // System.out.println(ch2.length);
    
42.                                 if (!ch1[i].contains(ch2[j])) {
    
43.                                         String s = ch1[i] + ch2[j];
    
44.                                         sbf.append(s);
    
45.                                         sbf.append("*");
    
46.                                 }
    
47.                         }
    
48.                 }
    
49.                 // 切割sbf
    
50.                 String s = sbf.toString();
    
51.                 System.out.println(s);
    
52.                 String regex = "[*]";
    
53.                 ch3 = s.split(regex);
    
54.                 for (String string : ch3) {
    
55.                         System.out.println(string);
    
56.                 }
    
57.                 if (k <= ch1.length) {
    
58.                         myout(ch1, ch3);
    
59.                 }
    
60.         }
    
61. }

复制代码

下面是解决方案：

1. package com.itheima;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. public class Test7 {
   
6. 
   
7.         /**
   
8.          * 7、编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如： 原始字符串是"abc"，打印得到下列所有组合情况： "a" "b"
   
9.          * "c" "ab" "bc" "ca" "ba" "cb" "ac" "abc" "acb" "bac" "bca" "cab" "cba"
   
10.          *
    
11.          * 思路：1，将字符串拆分为单个字符 2，使用递归算法进行组合
    
12.          *                
    
13.          */
    
14.         //定义静态变量k 控制递归次数
    
15.         static int k=1;
    
16.         //自定义异常，用于跳出递归的死循环
    
17.         @SuppressWarnings("serial")
    
18.         static class StopException extends RuntimeException{}
    
19.         public static void main(String[] args) {
    
20.                  System.out.println("请输入所要转换的字母或单词！");
    
21.                  //定义并初始化键盘读入语句
    
22.                  Scanner sc = new Scanner(System.in);
    
23.                  //声明字符串接收从键盘读取的字符串
    
24.                  String str = sc.nextLine();
    
25.                  //捕获自定义异常，用于跳出递归
    
26.                 try {
    
27.                         printfirst(str);
    
28.                 } catch (StopException e) {
    
29.                 }
    
30.         }
    
31. 
    
32.         public static void printfirst(String str) {
    
33.                 //定义两个字符串数组并获取所输入字符串的单个字符加入到数组中
    
34.                 //用于对双字符串的匹配合成。
    
35.                 int x = str.length();
    
36.                 String[] ch1 = new String[x];
    
37.                 String[] ch2 = new String[x];
    
38.                 for (int i = 0; i < str.length(); i++) {
    
39.                         ch1[i] = str.substring(i, i + 1);
    
40.                         ch2[i] = str.substring(i, i + 1);
    
41.                 }
    
42.                 //遍历数组输出题目要求的单个字符
    
43.                 for (String string1 : ch1) {
    
44.                         System.out.print(string1+" ");
    
45.                 }
    
46.                 //调用匹配的递归函数，并将数组ch1 ch2传进去
    
47.                 myout(ch1, ch2);
    
48.         }
    
49.         //定义函数，该函数用于将得到的任意两个字符数组，匹配出不重复的任意组合并输出。
    
50.         public static void myout(String[] ch1, String[] ch2) {
    
51.                 //定义StringBuffer 用于储存组合后的字符。
    
52.                 StringBuffer sbf = new StringBuffer();
    
53.                 //定义字符串数组用于储存组合后的字符串
    
54.                 String[] ch3 = null;
    
55.                 //对递归循环次数控制的变量k+1
    
56.                 k++;
    
57.                 //外层循环遍历匹配字符
    
58.                 for (int i = 0; i < ch1.length; i++) {
    
59.                         //内层循环遍历匹配字符
    
60.                         for (int j = 0; j < ch2.length; j++) {
    
61.                                 // System.out.println(ch2.length);
    
62.                                 //对传入的两个字符串数组进行匹配，被组合的字符串数组
    
63.                                 //中的数据不包含原始字符则进行组合。
    
64.                                 if (!(ch2[j].contains(ch1[i]))) {
    
65.                                         //定义新的字符串接收组合后的字符串
    
66.                                         String s = ch1[i] + ch2[j];
    
67.                                         //将字符串和*加入sbf
    
68.                                         sbf.append(s);
    
69.                                         sbf.append("*");
    
70.                                 }
    
71.                         }
    
72.                 }
    
73.                 // 将sbf转化为字符串方便进行切割操作
    
74.                 String s = sbf.toString();
    
75.                 //System.out.println(s);
    
76.                 //定义正则表达式并切割字符串加入字符数组中
    
77.                 String regex = "[*]";
    
78.                 ch3 = s.split(regex);
    
79.                 //遍历输出字符串数组
    
80.                 for (String string : ch3) {
    
81.                         System.out.print(string+" ");
    
82.                 }
    
83.                 //判断循环次数，并抛出自定义异常以跳出递归
    
84.                 if (k>=ch1.length){
    
85.                         //System.out.println(k);
    
86.                         throw new StopException();
    
87.                 }
    
88.                 //递归
    
89.                 myout(ch1, ch3);
    
90.         }
    
91.        
    
92. }
    

复制代码

使用抛出自定义异常解决递归死循环问题。

前面代码陷入死循环

楼主递归算法写的很赞，亮点：能想到通过设置静态变量k恰到好处的与自定义 RnutimeException  相结合，来准确的结束循环；
                                                 其中的小细节：1、StringBuffer 中的append  没必要写成：append（s）；append("*");
                                                                              用append(s + "*");就可以搞定了
                                                                        2、String regex = "

";ch3 = s.split(regex); 感觉没必要呀换成ch3 = s.split("*"); 感觉就可以了呀

真是学习了，我去琢磨琢磨了，谢谢分享