如何实现递归的任意集合的所有可能组合（JAVA）

有人能给我一些线索或帮助我写一个组合函数，它将输出集合的所有可能组合。我有个主意。但我觉得很难

Java中类似的东西

String set[] = {"Java","C++","Python"};

ArrayList<String> list = new ArrayList<String>();

public void combination(String[] set) {

    if (set.length == 0) {

       do nothing

    } else if (this a combination from the set) {
       add to the list
    }
}

stringset[]={“Java”、“C++”、“Python”}；
ArrayList=新建ArrayList（）；
公共无效组合（字符串[]集）{
如果（set.length==0）{
无所事事
}else if（这是集合中的组合）{
添加到列表中
}
}

这里有一个简单的例子，说明了字符串中所有字母的组合，只是给你一个算法。看看是否可以将算法转移到示例中

    public class StringLib {

    public static void combine(String str){
        int length=str.length();

        StringBuffer output=new StringBuffer();

        combination(str,length,output,0);
    }

    static void combination(String str, int length, StringBuffer output, int level){
        /* show arms-length recursion style with better peformance */
        if (level==length)
            return;
        else{
            for(int i=level;i<length;i++){
                output.append(str.charAt(i));
                System.out.println(output.toString());
                combination(str,length,output,i+1);
                output.deleteCharAt(output.length()-1);
            }
        }
    }


    public static void main(String[] args){
        combine("abc");
    }
}

/*Output:

a
ab
abc
ac
b
bc
c
*/

公共类StringLib{
公共静态无效组合（字符串str）{
int length=str.length（）；
StringBuffer输出=新的StringBuffer（）；
组合（str，长度，输出，0）；
}
静态void组合（字符串str、int-length、StringBuffer输出、int-level）{
/*显示具有更好性能的arms长度递归样式*/
如果（级别==长度）
返回；
否则{
对于（inti=level；我必须澄清一下，您确定需要组合还是置换？
import java.util.*;

public class permutations
{
  public static void main(String[] args)
  {
    String str = new String("abc");
    StringBuffer output = new StringBuffer();

    boolean used[] = {false, false, false};

    permute.printPermutations(0, output, used, str);
  }
}


public class permute{

  static void printPermutations(int level, StringBuffer output, boolean used[], String orig){
      int len = orig.length();
      if (level == len){
          System.out.println(output);
      }
      else{
          for (int i = 0; i < len; i++){    
              //recurse if not used already
              if (!used[i]){
                  output.append(orig.charAt(i));
                  used[i] = true;
                  printPermutations(level+1, output, used, orig);
                  output.deleteCharAt(output.length() - 1);
                  used[i] = false;
              }
          }
      }
  }
}




/*Output:

abc
acb
bac
bca
cab
cba

*/