多列表排列组合的顺序控制技巧

List<String> first = Arrays.asList("a", "b");
List<String> second = Arrays.asList("X", "Y", "Z");
List<String> third = Arrays.asList("1", "2");

[[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;
import java.util.List;
import java.util.stream.Collectors;

public class MultiListPermutations {

    // 用于存储所有生成的排列组合
    static List<List<String>> allPermutationsResult = 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>> permuteInputLists = new ArrayList<>();

        // 关键步骤1：反转输入列表的添加顺序
        // 按照期望的最慢变化元素（third）到最快变化元素（first）的顺序添加
        permuteInputLists.add(new ArrayList<>(third));  // 深度0将遍历third
        permuteInputLists.add(new ArrayList<>(second)); // 深度1将遍历second
        permuteInputLists.add(new ArrayList<>(first));  // 深度2将遍历first

        // 调用递归方法生成排列
        permute(permuteInputLists, allPermutationsResult, 0, "");

        // 打印所有生成的排列组合
        System.out.println("Generated Permutations (Desired Order):");
        for (List<String> re : allPermutationsResult) {
            System.out.println(re);
        }
    }

    /**
     * 递归生成多列表的排列组合。
     *
     * @param lists   包含所有待排列子列表的列表。
     * @param result  用于存储最终排列组合的列表。
     * @param depth   当前的递归深度，对应于正在处理的子列表索引。
     * @param current 当前正在构建的排列组合字符串。
     */
    public static void permute(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());

            // 关键步骤2：反转当前生成的组合，以匹配原始列表的逻辑顺序
            Collections.reverse(current_list);

            // 将反转后的组合添加到结果列表中
            result.add(current_list);
            return;
        }

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

permuteInputLists.add(new ArrayList<>(third));
permuteInputLists.add(new ArrayList<>(second));
permuteInputLists.add(new ArrayList<>(first));

List<String> current_list = current.chars().mapToObj(e -> Character.toString((char)e))
                                   .collect(Collectors.toList());
Collections.reverse(current_list); // 关键的反转操作
result.add(current_list);