地图值的笛卡尔乘积[重复]

Question

我有如下地图：

{"A" : ["A1", "A2", "A3"], "B" : ["B1", "B2", "B3"]}

我想得到如下数据：

A1, B1
A1, B2
A1, B3
A2, B1
A2, B2
...

我尝试了如下：

for (String aKey : map.get("A"))
    for (String bKey : map.get("B"))
        // work with aKey + bKey

但这不是我想要的代码，因为地图数据是动态的和不可预知的。

所以我应该像下面这样得到地图数据，但不能像我想要的那样：

for (String key : map.keySet())
    for (String values : map.get(key))
        // unable to make data I want

Answer 1

如果您有一个列表映射，您可以使用映射和减少方法获得其值的笛卡尔乘积。此代码可用于任意数量的列表。

在线试试吧！

// a map of lists
Map<String, List<String>> map = new TreeMap<>();
map.put("A", Arrays.asList("A1", "A2"));
map.put("B", Arrays.asList("B1", "B2"));
map.put("C", Arrays.asList("C1", "C2"));

// cartesian product of the map values
List<List<String>> cp = map.values().stream()
        // represent each element of a list as a singleton list
        .map(list -> list.stream().map(Arrays::asList)
                // Stream<List<List<String>>>
                .collect(Collectors.toList()))
        // summation of pairs of list into a single list
        .reduce((list1, list2) -> list1.stream()
                // combinations of inner lists
                .flatMap(inner1 -> list2.stream()
                        // concatenate into a single list
                        .map(inner2 -> Stream.of(inner1, inner2)
                                .flatMap(List::stream)
                                .collect(Collectors.toList())))
                // list of combinations
                .collect(Collectors.toList()))
        // otherwise an empty list
        .orElse(Collections.emptyList());

// output
map.forEach((k, v) -> System.out.println(k + ": " + v));
cp.forEach(System.out::println);

输出：

A: [A1, A2]
B: [B1, B2]
C: [C1, C2]
[A1, B1, C1]
[A1, B1, C2]
[A1, B2, C1]
[A1, B2, C2]
[A2, B1, C1]
[A2, B1, C2]
[A2, B2, C1]
[A2, B2, C2]

^{另请参阅：如何在Java中的任意数字组上创建笛卡尔乘积？}

Answer 2

您已经正确地理解了，不能使用一组静态嵌套循环创建任意数据的笛卡尔积。您需要的是一组嵌套循环的动态集合。我想您在最后一段代码中尝试过这一点。您似乎也明白，您需要的嵌套循环数量与数据中的集合数量相同。问题仍然是：如何编程动态数量的嵌套循环。

基本上有两种方法来执行动态数量的嵌套循环：递归和迭代。两者都获得相同的结果，性能（在时间和内存方面）应该相似。如果实现得好，那就是。

这里有两个类似的问题，一个明确要求迭代解决方案：

• 如何在Java中创建任意数字组上的笛卡尔积

试着理解两者。你的大脑可能更喜欢其中一个，但至少了解两者是值得的。

递归方法还有一个额外的问题，因为递归可能更难理解：模拟嵌套循环