Java中如何动态生成符合位置字符规则的所有字符串？

首先明确：Java标准库没有提供正则表达式的「反向操作」——也就是根据正则规则自动生成所有匹配字符串的内置功能。但针对你的需求，我们可以实现完全动态的生成方案，无需提前写死嵌套循环。

方案1：回溯递归实现 #

递归回溯是处理这类动态组合问题的常用思路，核心是逐层构建字符串，处理完一组字符后递归进入下一组，完成后回溯处理下一个选项。

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

public class StringCombiner {
    public static void main(String[] args) {
        String[] first = {"A", "B", "C"};
        String[] second = {"1", "2", "3"};
        String[] third = {"X", "Y", "Z"};

        List<String> combinations = generateAllCombinations(first, second, third);
        combinations.forEach(System.out::println);
    }

    public static List<String> generateAllCombinations(String[]... charGroups) {
        List<String> result = new ArrayList<>();
        backtrack(result, new StringBuilder(), charGroups, 0);
        return result;
    }

    private static void backtrack(List<String> result, StringBuilder currentStr, String[][] charGroups, int currentGroup) {
        // 所有位置处理完毕，保存当前组合
        if (currentGroup == charGroups.length) {
            result.add(currentStr.toString());
            return;
        }

        // 遍历当前位置的所有可选字符
        for (String c : charGroups[currentGroup]) {
            currentStr.append(c);
            // 递归处理下一个位置
            backtrack(result, currentStr, charGroups, currentGroup + 1);
            // 回溯，移除当前字符，准备处理下一个选项
            currentStr.deleteCharAt(currentStr.length() - 1);
        }
    }
}

这个方法不管你传入多少组字符（对应字符串长度）、每组有多少个可选字符，都能自动生成所有合法组合，完全不需要修改循环结构。

方案2：迭代逐步构建 #

如果你不想用递归，也可以用迭代的方式，从第一组字符开始，逐步和后续每组的字符拼接，更新结果集：

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

public class StringCombinerIterative {
    public static void main(String[] args) {
        String[] first = {"A", "B", "C"};
        String[] second = {"1", "2", "3"};
        String[] third = {"X", "Y", "Z"};

        List<String> combinations = generateCombinationsIterative(first, second, third);
        combinations.forEach(System.out::println);
    }

    public static List<String> generateCombinationsIterative(String[]... charGroups) {
        if (charGroups.length == 0) {
            return new ArrayList<>();
        }

        List<String> result = new ArrayList<>();
        // 初始化结果为第一组的所有字符
        for (String c : charGroups[0]) {
            result.add(c);
        }

        // 依次处理后续每组字符，和现有结果拼接
        for (int i = 1; i < charGroups.length; i++) {
            List<String> temp = new ArrayList<>();
            for (String existing : result) {
                for (String c : charGroups[i]) {
                    temp.add(existing + c);
                }
            }
            result = temp;
        }

        return result;
    }
}

这种方式逻辑直观，每一步都基于上一步的结果扩展，同样支持任意数量的字符组和每组任意数量的字符。

内容的提问来源于stack exchange，提问作者wannaBeDev