Java 获得一切可能——学业

我需要做的是获取一个字符串数组，其中每个元素的精确长度为2，并使用每个字符串中的每个字符找到所有可能的元素组合。我的意思是字符串数组{“Ss”，“Ff”}返回“SF”，“SF”，“SF”，“SF”。我已经尝试过一种循环方法，它计算迭代次数，然后根据迭代次数选择一个字母，但它只适用于具有单个元素的数组：

    public String [] generatePossibilities(String [] s)
{
    if(s[0].length() != 2)
        throw new IllegalArgumentException();

    String [] r = new String [s.length * 2];

    for(int i = 0; i < r.length; i++)
    {
        r[i] = getPossibility(i, s);
    }

    return r;
}

private String getPossibility(int iteration, String [] source)
{
    int [] choose = new int [source.length];
    for(int i = 0; i < choose.length; i++)
    {
        choose[i] = 0;
    }

    for(int i = choose.length - 1; i >= 0; i--)
    {
        if(iteration < 1)
            break;

        choose[i] = 1;
        iteration--;
    }

    String result = "";
    for(int i = 0; i < source.length; i++)
        result += source[i].substring(choose[i], choose[i] + 1);

    return result;
}

公共字符串[]生成可能性（字符串[]s）
{
如果（s[0]。长度（）！=2）
抛出新的IllegalArgumentException（）；
字符串[]r=新字符串[s.length*2]；
对于（int i=0；i=0；i--）
{
if（迭代<1）
打破
选择[i]=1；
迭代--；
}
字符串结果=”；
for（int i=0；i

已解决谢谢Sven

    public String [] generatePossibilities(String [] s)
{
    if(s[0].length() != 2)
        throw new IllegalArgumentException();

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

    for(int i = s.length - 1; i >= 0; i--)
    {           
        for(int j = 0; j < s[i].length(); j++)
        {
            String c = s[i].substring(j, j + 1);

            if(ra.size() < 2)
            {
                ra.add(c);
            }

            else
            {
                for(int k = 0; k < ra.size(); k++)
                {
                    String s1 = ra.get(k);
                    if(s1.substring(0, 1).equalsIgnoreCase(c))
                        continue;
                    else
                    {
                        s1 = c + s1;
                        ra.add(s1);
                    }
                }
            }
        }

        for(int j = 0; j < ra.size(); j++)
        {
            if(ra.get(j).length() != s.length - i)
            {
                ra.remove(j);
                j--;
            }
        }
    }

    String [] r = new String [ra.size()];
    for(int i = 0; i < r.length; i++)
    {
        r[i] = ra.get(i);
    }
    return r;
}

公共字符串[]生成可能性（字符串[]s）
{
如果（s[0]。长度（）！=2）
抛出新的IllegalArgumentException（）；
ArrayList ra=新的ArrayList（）；
对于（int i=s.length-1；i>=0；i--）
{           
对于（int j=0；j

我将迭代从最后一个元素到第一个元素的字符元组数组。在每个步骤中，您都会将上一次迭代的可能性附加到每个当前角色。因此，您可以在每个步骤中将元素加倍。

---

因此，对于第一次迭代中的示例，您有{Ff}，这将导致两个字符串“F”和“F”。在下一步中，您获取{Ss}的每个字符，并将最后一步的每个字符串附加到它，得到“SF”、“SF”、“SF”和“SF”。然后，您可以继续使用更多字符元组。

您能再举一些例子吗。源数组只包含2个字符串还是可以包含更多字符串？@ashok\p它可以包含无限量的字符串，但每个字符串只有2个字符。另一个例子是{“SS”、“Ff”、“dd”}，它应该产生另一个字符串数组，其长度为2*源数组的长度（所有组合）和字符串{“SFd”、“SFd”、“SFd”、“SFd”、…）。+1，以供自己尝试并两次显示某些代码降表决？为什么我值得这样做？