/*
* 编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：

原始字符串是"abc"，打印得到下列所有组合情况：
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"

1. package com.itheima;
   
2. public class Test8{
   
3. 
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 String a=new String("abc");
   
7.                 String b=new String();
   
8.                 //双循环获取所有组合
   
9.                 for(int i=0;i<a.length();i++)
   
10.                 {
    
11.                         for(int j=i;j<a.length();j++)
    
12.                         {
    
13. 
    
14.                                  b=converse(a,i,j);
    
15. 
    
16.                                 sop(b.substring(i,j+1),"");
    
17.                                
    
18.                         }
    
19.                 }
    
20.         }
    
21.         //获取从1到length长度子串的所有组合，并输出
    
22.         public static void sop(String s,String n)
    
23.         {
    
24.                 if (s.length() == 0)
    
25.                 {  
    
26.             System.out.println(n);  
    
27.         } else {  
    
28.                             for (int i = 0; i < s.length(); ++i)
    
29.                             {  
    
30.                                 sop(s.substring(1), n + s.charAt(0));  
    
31.                                 s = s.substring(1) + s.charAt(0);  
    
32.                             }  
    
33.                     }
    
34.        
    
35.         }
    
36.         //自定义函数，用于交换字符串中相应字符的位置
    
37.         public static String converse(String a,int i,int j)
    
38.         {
    
39.                 char[] b=a.toCharArray();
    
40.                 char temp;
    
41.                 temp=b[i];
    
42.                 b[i]=b[j];
    
43.                 b[j]=temp;
    
44.                 return new String(b);
    
45.         }
    
46.         }
    

复制代码

* */

这个楼主也可以参考一下

1. import java.util.ArrayList;
   
2. 
   
3. 
   
4. public class Test5 {
   
5.         public static void main(String args[])
   
6.         {
   
7.                 String s="abc";
   
8.                 //调用排序方法
   
9.                 combinations(s);
   
10.         }
    
11.         //排序方法
    
12.         private static void combinations(String s) {
    
13.                 //创建一个Arraylist用来存放结果
    
14.                 ArrayList<String> list =new ArrayList<String>();
    
15.                 //将字符串拆分成单个字符存入ArrayList
    
16.                 char[] ch = s.toCharArray();
    
17.                 for(char c:ch)
    
18.                 {
    
19.                         list.add(c+"");
    
20.                        
    
21.                 }
    
22.                 //进行循环存入
    
23.                 int len=s.length();  //记录随着长度增长产生的字符串个数
    
24.                 int start=0;         //用于记数
    
25.                 for(int l=2;l<=s.length();l++)  //l表示字符串长度
    
26.                 {       
    
27.                         //取出l长度的所有字符串
    
28.                         for(int x=0;x<len;start++,x++)
    
29.                         {        //在l-1长度的字符串末尾添加单个字符串，产生长度为l的字符串
    
30.                                 for(int in=0;in<s.length();in++)
    
31.                                 {
    
32.                                         list.add(list.get(start)+list.get(in));
    
33.                                 }
    
34.                         }
    
35.                         len=len*s.length();
    
36.                 }
    
37.                 //调用输出字符串方法
    
38.                 print(list);
    
39.         }
    
40.         //输出字符串
    
41.         private static void print(ArrayList<String> list) {
    
42.                 for(String  ls:list)
    
43.                 {       
    
44.                         //判断字符串是否含有相同元素，不含有则输出
    
45.                         if(!isSame(ls))
    
46.                         {
    
47.                                 System.out.println(ls);
    
48.                         }
    
49.                 }
    
50.                
    
51.         }
    
52. 
    
53.         private static boolean isSame(String ls) {
    
54.                 //对于长度大于1的进行判断
    
55.                 if(ls.length()>1)
    
56.                 {       
    
57.                         //依次取出该字符串前一半的元素
    
58.                         for(int n=0;n<ls.length()/2+1;n++)
    
59.                                 {
    
60.                                         //对取出的元素进行第一次出现和最后一次出现位置比较，相同则说明只存在一个该元素
    
61.                                         if(ls.indexOf(ls.charAt(n))==ls.lastIndexOf(ls.charAt(n)))
    
62.                                                 {
    
63.                                                
    
64.                                                         continue;
    
65.                                                        
    
66.                                                 }
    
67.                                         return true;//否则返回True表示存在相同元素
    
68.                                 }
    
69.                                 return false;//所有元素判断完，返回false,表示无相同元素。
    
70.                 }
    
71.                
    
72.                 return false;
    
73.                
    
74.                
    
75.                
    
76.                
    
77.                  
    
78.         }
    
79. 
    
80. }
    

复制代码

pandapan 发表于 2014-5-19 18:08
娱乐一下吧,你猜我猜你猜不猜?

你猜我猜你猜我猜不猜？

流沙 发表于 2014-5-19 06:37
你猜。。。。。。。。。。。。。。。。

娱乐一下吧,你猜我猜你猜不猜?:lol:lol

pandapan 发表于 2014-5-18 22:56
那么如果是abcd呢？4重循环？a~z呢？

你猜。。。。。。。。。。。。。。。。

流沙 发表于 2014-5-17 15:46
1、想获取字符串的长度。
2、将字符串单个打印一遍（这个应该简单）；

那么如果是abcd呢？4重循环？a~z呢？

这个问题在上期的论坛中出现过，不过我还是解答一下吧。
这个问题的处理，正如楼上的所说，用普通的方法处理不太好使，使用递归处理比较合适。
整体的思维方式是，
1.将串分成两部分，一部分为前缀，即 不需要修改的，另外一部分是剩下的串，
2.如果剩下的串的长度为1，那么构成规则便只有一种，就是前缀+剩下的长度为1的串
3. 否则，便可以将剩下的串进行再次分割，将剩下的串的每一位拼接到前缀，递归寻找结果
我就把上次给他人的解答给你吧。

1. 
   
2. public class Test {
   
3.         private static int count=0;
   
4.         public static void main(String[] args) {
   
5.                 // TODO Auto-generated method stub
   
6.                 getDiffCombination("","abc");
   
7.                 System.out.println(count);
   
8.         }
   
9.         
   
10.         /**
    
11.          * 整体的思维方式是，将串分成两部分，一部分为前缀，即 不需要修改的，另外一部分是剩下的串，
    
12.          * 如果剩下的串的长度为1，那么构成规则便只有一种，就是前缀+剩下的长度为1的串
    
13.          * 否则，便可以将剩下的串进行再次分割，将剩下的串的每一位拼接到前缀，递归寻找结果
    
14.          * @param prefix 字符串的构成前缀
    
15.          * @param strLeft 剩下的字符串
    
16.          */
    
17.         private static void getDiffCombination(String prefix,String strLeft){
    
18.                 if(strLeft.length()==1){
    
19.                         System.out.println(prefix+strLeft);
    
20.                         count++;
    
21.                         return;
    
22.                 }
    
23.                
    
24.                 for(int i=0;i<strLeft.length();i++){
    
25.                         StringBuilder sb = new StringBuilder(strLeft);
    
26.                         String str = prefix+strLeft.substring(i, i+1);
    
27.                         System.out.println(str);
    
28.                         count++;
    
29.                         getDiffCombination(str,sb.deleteCharAt(i).toString());
    
30.                 }
    
31.         }        
    
32. }

复制代码

另外，上次那个提问的同学的方法，我就不列举了，将地址发给你吧。你可以参考参考http://bbs.itheima.com/thread-117433-1-1.html
希望能够帮到你

yongdigui.      

这个靠谱不？

1. public static void str(){
   
2.                 String str = "abc";
   
3.                 char[] chr = str.toCharArray();
   
4.                 for(int x = 0; x < chr.length; x++){
   
5.                         for(int y = 0 ; y < chr.length; y++){
   
6.                                 if(x != y)
   
7.                                         System.out.println(new String(""+chr[x]+chr[y]));
   
8.                                 for(int z = 0; z < chr.length; z++){
   
9.                                         if(x != y && y != z && x != z)
   
10.                                                 System.out.println("" + chr[x]+ chr[y]+ chr[z]);                                       
    
11.                                 }
    
12.                         }
    
13.                         System.out.println(chr[x]);
    
14.                 }
    
15.         }

复制代码

1、想获取字符串的长度。
2、将字符串单个打印一遍（这个应该简单）；

3、将两个字符串的打印一遍，
循环方式是 用第一个a+ 除a以外的每个字符串打印  在用第二个b+除b以外每个字符串打印。

4、这个我感觉好像需要三重循环，
用第一个a和第二个b相连+出ab以外的所有字符打印。
一次类推就能出来

我的想法：没有实验：能看明白么？