Java 生成范围内所有可能的字符串

我需要生成特定范围内所有可能的字符串。 例如
上限-

aaa

下限-

ccc

也有可能出现的情况

aab-caa

，

hhu-kkk

，但不是

aaz-ccc

价值观应该是

    aaa
    aab
    aac
    aba
    abb
    abc
    aca
    acb
    acc
    caa
    cab
    cac
    cca
    ccb
    ccc

我写了这样的方法，但它不能正确地工作，我不知道如何正确地做到这一点，这是太难了，我现在要抓住所有可能的情况，请帮助

 public static List<String> generateAllPossibleStrings(String start, String end) {
        if (start.length() != end.length()) {
            return null;
        }
        List<String> variants = new ArrayList<>();
        char startArray[] = start.toCharArray();
        char endArray[] = end.toCharArray();
        char currentArray[] = Arrays.copyOf(startArray, startArray.length);
        variants.add(new String(currentArray));
        for (int i = startArray.length - 1; i >= 0; i--) {
            while (currentArray[i] != endArray[i]) {
                currentArray[i]++;
                variants.add(new String(currentArray));
                for (int j = startArray.length - 1; j > i; j--) {
                    while (currentArray[j] != endArray[j]) {
                        currentArray[j]++;
                        variants.add(new String(currentArray));
                    }
                    currentArray[j] = startArray[j];

                }
            }
            currentArray[i] = startArray[i];
        }

        System.out.println(Arrays.toString(variants.toArray()));
        return variants;
    }

如您所见，缺少一些值

请帮助更正此方法并使其正确工作，或者它应该作为递归方法实现

解释

---

为什么

aaz-ccc

是不可能的，因为下界（

ccc

）中的任何字符都应该比上界（

aaz

）中的相应字符更大，在本例中

z

比

c

更大，所以这是不正确的。

编辑：我可能误解了这个问题，我认为每个位置的结束字符串都在开始字符串的上方，但其他示例中的情况似乎并非如此。你能说明你应该在hhu kkk上输出什么，并解释aaz ccc有什么问题吗

EDIT2：正如我所怀疑的，hhu kkk也是一个不正确的输入（u>k），你应该再次编辑你的问题

将字符串视为一个递增的数字

当您在一个位置超过结束字符串时，您会将开始字符串的字母改为递增下一个字母，就像带进位的加法一样

这是您的代码的修改版本。现在，它还检查两个字符串是否满足您描述的所有属性（如果函数使用正确，则不需要这些属性）

公共静态列表generateAllPossibleStrings（字符串开始，字符串结束）{
如果（开始==null | |结束==null）
返回null；
if（start.length（）！=end.length（））
返回null；
int n=start.length（）；
列表变量=新的ArrayList（）；
char startArray[]=start.toCharArray（）；
char endArray[]=end.toCharArray（）；
char currentArray[]=Arrays.copyOf（startArray，startArray.length）；
添加（新字符串（currentArray））；
//我们检查起始字符串是否确实高于指定的结束字符串
//如果不是这样，我们输出一个空字符串
布尔可能=真；
对于（int i=0；iEDIT）：我可能误解了这个问题，我认为每个位置的结束字符串都在开始字符串之上，但从其他示例来看，情况似乎并非如此。您能否说明您应该在hhu kkk上输出什么，并解释aaz ccc的错误

EDIT2：正如我所怀疑的，hhu kkk也是一个不正确的输入（u>k），你应该再次编辑你的问题

将字符串视为一个递增的数字

当您在一个位置超过结束字符串时，您会将开始字符串的字母改为递增下一个字母，就像带进位的加法一样

这是您的代码的修改版本。它现在还检查两个字符串是否满足您描述的所有属性（如果函数使用正确，这应该不是必需的）

公共静态列表generateAllPossibleStrings（字符串开始，字符串结束）{
如果（开始==null | |结束==null）
返回null；
if（start.length（）！=end.length（））
返回null；
int n=start.length（）；
列表变量=新的ArrayList（）；
char startArray[]=start.toCharArray（）；
char endArray[]=end.toCharArray（）；
char currentArray[]=Arrays.copyOf（startArray，startArray.length）；
添加（新字符串（currentArray））；
//我们检查起始字符串是否确实高于指定的结束字符串
//如果不是这样，我们输出一个空字符串
布尔可能=真；
对于（inti=0；i我将使用，将实现拆分为小的clear方法并使用递归

import java.util.ArrayList;
import java.util.List;

public final class Permutations {

    public static List<String> generate(String begin, String end) {
        List<String> result = new ArrayList<>();

        String current = begin;
        while (true) {
            result.add(current);
            if (current.equals(end))
                break;
            current = getNextPermutation(current, end);
        }

        return result;
    }

    private static String getNextPermutation(String current, String end) {
        char[] candidate = current.toCharArray();
        createNextPermutation(candidate, current.length()-1, end);
        return String.valueOf(candidate);
    }

    private static void createNextPermutation(char[] candidate, int index, String end) {
        char c = getNextChar(candidate[index]);
        if (c > end.charAt(index)) {
            candidate[index] = 'a';
            createNextPermutation(candidate, index-1, end);
        }
        else {
            candidate[index] = c;
        }
    }

    private static char getNextChar(char c) {
        return (char)(c + 1);
    }
}

import java.util.ArrayList；
导入java.util.List；
公共最终类排列{
公共静态列表生成（字符串开始、字符串结束）{
列表结果=新建ArrayList（）；
字符串电流=开始；
while（true）{
结果。添加（当前）；
如果（当前等于（结束））
打破
当前=GetNextPermutate（当前，结束）；
}
返回结果；
}
私有静态字符串getNextPermutation（字符串当前，字符串结束）{
char[]candidate=current.toCharArray（）；
CreateNextPermutate（候选，current.length（）-1，end）；
返回字符串.valueOf（候选者）；
}
私有静态void CreateNextPermutate（字符[]候选，整数索引，字符串结束）{
char c=getNextChar（候选者[索引]）；
如果（c>结束字符（索引））{
候选人[索引]=“a”；
CreateNextPermutate（候选者，索引-1，结束）；
}
否则{
候选者[索引]=c；
}
}
私有静态字符getNextChar（字符c）{
返回（字符）（c+1）；
}
}
我会使用，将实现拆分为小的clear方法并使用递归

import java.util.ArrayList;
import java.util.List;

public final class Permutations {

    public static List<String> generate(String begin, String end) {
        List<String> result = new ArrayList<>();

        String current = begin;
        while (true) {
            result.add(current);
            if (current.equals(end))
                break;
            current = getNextPermutation(current, end);
        }

        return result;
    }

    private static String getNextPermutation(String current, String end) {
        char[] candidate = current.toCharArray();
        createNextPermutation(candidate, current.length()-1, end);
        return String.valueOf(candidate);
    }

    private static void createNextPermutation(char[] candidate, int index, String end) {
        char c = getNextChar(candidate[index]);
        if (c > end.charAt(index)) {
            candidate[index] = 'a';
            createNextPermutation(candidate, index-1, end);
        }
        else {
            candidate[index] = c;
        }
    }

    private static char getNextChar(char c) {
        return (char)(c + 1);
    }
}

import java.util.ArrayList；
导入java.util.List；
公共最终类排列{
公共静态列表生成（字符串开始、字符串结束）{
列表结果=新建ArrayList（）；
字符串电流=开始；
while（true）{
结果。添加（当前）；
如果（当前等于（结束））
打破
当前=GetNextPermutate（当前，结束）；
}
返回结果；
}
私有静态字符串getNextPermutation（字符串当前，字符串结束）{
char[]candidate=current.toCharArray（）；
CreateNextPermutate（候选，current.length（）-1，end）；
返回字符串.valueOf（候选者）；
}
私有静态void CreateNextPermutate（字符[]候选，整数索引，字符串结束）{
char c=getNextChar（候选者[索引]）；
如果
import java.util.ArrayList;
import java.util.List;

public final class Permutations {

    public static List<String> generate(String begin, String end) {
        List<String> result = new ArrayList<>();

        String current = begin;
        while (true) {
            result.add(current);
            if (current.equals(end))
                break;
            current = getNextPermutation(current, end);
        }

        return result;
    }

    private static String getNextPermutation(String current, String end) {
        char[] candidate = current.toCharArray();
        createNextPermutation(candidate, current.length()-1, end);
        return String.valueOf(candidate);
    }

    private static void createNextPermutation(char[] candidate, int index, String end) {
        char c = getNextChar(candidate[index]);
        if (c > end.charAt(index)) {
            candidate[index] = 'a';
            createNextPermutation(candidate, index-1, end);
        }
        else {
            candidate[index] = c;
        }
    }

    private static char getNextChar(char c) {
        return (char)(c + 1);
    }
}