多列表自定义顺序排列组合的实现方法

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

public class PermutationGenerator {

    static List<List<String>> result = new ArrayList<>();

    // 原始的递归排列方法
    public static void permuteStandard(List<List<String>> lists, List<List<String>> result, int depth, String current) {
        // 基本情况：当递归深度达到列表总数时，表示一个完整的组合已经生成
        if (depth == lists.size()) {
            // 将当前组合字符串转换为List<String>
            List<String> 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++) {
            // 将当前元素添加到组合字符串中，并进入下一层递归
            permuteStandard(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>> inputLists = new ArrayList<>();
        inputLists.add(first);
        inputLists.add(second);
        inputLists.add(third);

        System.out.println("--- 原始排列顺序 ---");
        permuteStandard(inputLists, result, 0, "");
        for (List<String> re : result) {
            System.out.println(re);
        }
        result.clear(); // 清空结果以便后续测试
    }
}

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

public class CustomPermutationGenerator {

    static List<List<String>> result = new ArrayList<>();

    /**
     * 生成多列表元素的排列组合，并支持自定义输出顺序。
     * @param lists 包含多个字符串列表的列表。
     * @param result 存储所有生成的排列组合的列表。
     * @param depth 当前递归的深度，表示正在处理第几个列表。
     * @param current 当前已经构建的组合字符串。
     */
    public static void permuteCustomOrder(List<List<String>> lists, List<List<String>> result, int depth, String current) {
        // 基本情况：当递归深度等于列表总数时，表示一个完整的组合已经生成
        if (depth == lists.size()) {
            // 将当前组合字符串转换为List<String>
            List<String> current_list = current.chars()
                                               .mapToObj(e -> Character.toString((char)e))
                                               .collect(Collectors.toList());
            // 关键步骤1: 反转生成的组合列表，以匹配原始列表的逻辑顺序
            Collections.reverse(current_list);
            result.add(current_list); // 将反转后的组合添加到结果集中
            return;
        }

        // 递归步骤：遍历当前深度的列表中的所有元素
        for (int i = 0; i < lists.get(depth).size(); i++) {
            // 将当前元素添加到组合字符串中，并进入下一层递归
            // 注意：这里的lists.get(depth)是经过重新排序的输入列表
            permuteCustomOrder(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");

        // 关键步骤2: 调整输入列表的顺序
        // 为了让 third 列表的元素变化最慢，它应该在最外层循环，即作为第一个被处理的列表
        // 为了让 first 列表的元素变化最快，它应该在最内层循环，即作为最后一个被处理的列表
        List<List<String>> reorderedInputLists = new ArrayList<>();
        reorderedInputLists.add(new ArrayList<>(third)); // 优先处理 third
        reorderedInputLists.add(new ArrayList<>(second)); // 其次处理 second
        reorderedInputLists.add(new ArrayList<>(first));  // 最后处理 first

        System.out.println("--- 自定义排列顺序 ---");
        permuteCustomOrder(reorderedInputLists, result, 0, "");

        for (List<String> re : result) {
            System.out.println(re);
        }
    }
}