/*第6题：
* 编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
*原始字符串是"abc"，打印得到下列所有组合情况：
*"a" "b" "c"
*"ab" "bc" "ca" "ba" "cb" "ac"
*"abc" "acb" "bac" "bca" "cab" "cba"
*分析：根据上面组成结构采用双重循环，可以先建一个数组用于存放第一行最基本的元素，
*    第一行元素循环组合成第二行字符串得到新字符串，将新的字符串封装到ArrayList中并记录下最后一个元素位置
*    然后将ArrList变成数组，将其中元素均与最基本元素相结合，并记录下最后一个元素位置依次就可以得到所有的组合
*/
public class Test6 {
        public static void sop(Object obj){
                System.out.println(obj);
        }
        public static void main(String[] args){
                String str ="abc";
                get(str);
        }
        public static void get(String str){
                //创建字符串长度的数组用以存放最基本元素
                String[] arr=new String[str.length()];
                //创建ArrList集合用以存放后续数据
                ArrayList<String> mylist=new ArrayList<String>();
                for(int k=0;k<str.length();k++){
                        arr[k]=str.substring(k, k+1);
                        mylist.add(str.substring(k, k+1));
                }
               
                int a=0;
                int b=mylist.size();//作为标记新元素位置
               
                for(int i=a;i<b;i++){//外循环控制新元素的循环
                        for(int j=0;j<str.length();j++){//内循环负责新元素与基本元素的结合
                                //将mylist变为数组形式方便利用数组的contain方法
                                if(!mylist.toArray()[i].toString().contains(arr[j])){
                                        mylist.add(mylist.toArray()[i]+arr[j]);
                                        a=a+1;
                                        b=b+1;//每增加一个元素a就加一
                                }
                        }
                }
                Iterator<String> it = mylist.iterator();//创建迭代器
                while(it.hasNext()){
                        sop(it.next());
                }
        }       
}

地32行、33行完全都是多余的！

1. package com.itheima;
   
2. import java.util.ArrayList;
   
3. import java.util.Iterator;
   
4. 
   
5. /*第6题：
   
6. * 编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
   
7. *原始字符串是"abc"，打印得到下列所有组合情况：
   
8. *"a" "b" "c"
   
9. *"ab" "bc" "ca" "ba" "cb" "ac"
   
10. *"abc" "acb" "bac" "bca" "cab" "cba"
    
11. *分析：根据上面组成结构采用双重循环，可以先建一个数组用于存放第一行最基本的元素，
    
12. *    第一行元素循环组合成第二行字符串得到新字符串，将新的字符串封装到ArrayList中并记录下最后一个元素位置
    
13. *    然后将ArrList变成数组，将其中元素均与最基本元素相结合，并记录下最后一个元素位置依次就可以得到所有的组合
    
14. */
    
15. public class Test6 {
    
16.         public static void sop(Object obj){
    
17.                 System.out.println(obj);
    
18.         }
    
19.         public static void main(String[] args){
    
20.                 String str ="abc";
    
21.                 get(str);
    
22.         }
    
23.         public static void get(String str){
    
24.                 //创建字符串长度的数组用以存放最基本元素
    
25.                 String[] arr=new String[str.length()];
    
26.                 //创建ArrList集合用以存放后续数据
    
27.                 ArrayList<String> mylist=new ArrayList<String>();
    
28.                 for(int k=0;k<str.length();k++){
    
29.                         arr[k]=str.substring(k, k+1);
    
30.                         mylist.add(str.substring(k, k+1));
    
31.                 }               
    
32.                 int a=0;
    
33.                 int b=mylist.size();//作为标记新元素位置               
    
34.                 for(int i=a;i<b;i++){//外循环控制新元素的循环
    
35.                         for(int j=0;j<str.length();j++){//内循环负责新元素与基本元素的结合
    
36.                                 //将mylist变为数组形式方便利用数组的contain方法
    
37.                                 if(!mylist.toArray()[i].toString().contains(arr[j])){
    
38.                                         mylist.add(mylist.toArray()[i]+arr[j]);
    
39.                                         a=a+1;
    
40.                                         b=b+1;//每增加一个元素a就加一
    
41.                                 }
    
42.                         }
    
43.                 }
    
44.                 Iterator<String> it = mylist.iterator();//创建迭代器
    
45.                 while(it.hasNext()){
    
46.                         sop(it.next());
    
47.                 }
    
48.         }       
    
49. }
    

复制代码