Java中多列表元素按特定顺序生成排列组合的递归实现

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class PermutationGenerator {

    // 假设result是外部定义的静态或实例变量
    // static List<List<String>> result = new ArrayList<>(); 

    public static void permute(List<List<String>> lists, List<List<String>> result, int depth, String current) {
        // 当递归深度达到列表总数时，表示一个完整的组合已生成
        if (depth == lists.size()) {
            List<String> current_list = new ArrayList<>();
            // 将current字符串拆分成字符列表
            current_list = current.chars().mapToObj(e -> Character.toString((char)e))
                                 .collect(Collectors.toList());
            result.add(current_list);
            return;
        }

        // 遍历当前深度的列表中的所有元素
        for (int i = 0; i < lists.get(depth).size(); i++) {
            // 将当前元素添加到current字符串，并递归到下一深度
            permute(lists, result, depth + 1, current + lists.get(depth).get(i));
        }
    }

    public static void main(String[] args) {
        List<String> first = Arrays.asList("a", "b");
        List<String> second = Arrays.asList("X", "Y", "Z");
        List<String> third = Arrays.asList("1", "2");

        List<List<String>> allLists = new ArrayList<>();
        allLists.add(first);
        allLists.add(second);
        allLists.add(third);

        List<List<String>> generatedResult = new ArrayList<>();
        permute(allLists, generatedResult, 0, "");

        System.out.println("原始方法输出:");
        for (List<String> re : generatedResult) {
            System.out.println(re);
        }
    }
}

原始方法输出:
[a, X, 1]
[a, X, 2]
[a, Y, 1]
[a, Y, 2]
[a, Z, 1]
[a, Z, 2]
[b, X, 1]
[b, X, 2]
[b, Y, 1]
[b, Y, 2]
[b, Z, 1]
[b, Z, 2]

[[a,X, 1], [b, X, 1], [a, Y, 1], [b, Y, 1], [a, Z, 1], [b, Z, 1], [a, X, 2], [b, X, 2], [a, Y, 2], [b, Y, 2], [a, Z, 2], [b, Z, 2]]

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections; // 引入Collections类
import java.util.List;
import java.util.stream.Collectors;

public class PermutationOrderController {

    static List<List<String>> result = new ArrayList<>(); // 静态变量用于存储结果

    public static void main(String args[]) {
        List<String> first = Arrays.asList("a", "b");
        List<String> second = Arrays.asList("X", "Y", "Z");
        List<String> third = Arrays.asList("1", "2");

        List<List<String>> permuteLists = new ArrayList<>();

        // 关键调整1: 按照期望的“最慢循环”到“最快循环”的顺序添加列表
        // 这里的顺序是：third -> second -> first
        permuteLists.add(new ArrayList<>(third));
        permuteLists.add(new ArrayList<>(second));
        permuteLists.add(new ArrayList<>(first));

        // 调用递归方法
        permute(permuteLists, result, 0, "");

        System.out.println("调整后方法输出:");
        for(List<String> re : result) {
            System.out.println(re);
        }
    }

    public static void permute(List<List<String>> lists, List<List<String>> result, int depth, String current) {
        if (depth == lists.size()) {
            List<String> current_list = new ArrayList<>();
            current_list = current.chars().mapToObj(e -> Character.toString((char)e))
                    .collect(Collectors.toList());

            // 关键调整2: 反转生成的单个组合的元素顺序
            Collections.reverse(current_list); 
            result.add(current_list);
            return;
        }

        for (int i = 0; i < lists.get(depth).size(); i++) {
            permute(lists, result, depth + 1, current + lists.get(depth).get(i));
        }
    }
}

调整后方法输出:
[a, X, 1]
[b, X, 1]
[a, Y, 1]
[b, Y, 1]
[a, Z, 1]
[b, Z, 1]
[a, X, 2]
[b, X, 2]
[a, Y, 2]
[b, Y, 2]
[a, Z, 2]
[b, Z, 2]