如何改造一個Map <string, list<string> > 進入列表<map<string, string> > 得到笛卡爾積？ </map<string,></string,>

Question

使用 Java 我試圖創建 map 的笛卡爾積，其中包含String鍵和List<String>值。 創建列表時，我需要保留鍵的值，如下所示：

• 來自Map<String, List<String>> Object
• 到List<Map<String, String>> Object

我還要求當原始 map 中的List<String>值為空時，在創建笛卡爾積時仍應將其視為單個值，以避免乘以 0 和不創建映射。 例如下面的 map：

{
    "Location Number" = {"100", "500"}
    "Department Number" = {"11", "22", "33"}
    "District Number" = {}
    "Preferred Language" = {"en-US"}
}

被翻譯成：

{
    {
        "Location Number" = "100"
        "Department Number" = "11"
        "District Number" = {}
        "Preferred Language" = "en-US"
    },
    {
        "Location Number" = "100"
        "Department Number" = "22"
        "District Number" = {}
        "Preferred Language" = "en-US"
    },
    {
        "Location Number" = "100"
        "Department Number" = "33"
        "District Number" = {}
        "Preferred Language" = "en-US"
    },
    {
        "Location Number" = "500"
        "Department Number" = "11"
        "District Number" = {}
        "Preferred Language" = "en-US"
    },
    {
        "Location Number" = "500"
        "Department Number" = "22"
        "District Number" = {}
        "Preferred Language" = "en-US"
    },
    {
        "Location Number" = "500"
        "Department Number" = "33"
        "District Number" = {}
        "Preferred Language" = "en-US"
    }
}

下面是我目前用來完成類似翻譯的代碼，但它沒有保留我需要的密鑰。 我不知道一般使用 Java 8 Streams 是否有可能完成此操作。

private static List<List<String>> createRuleListFromMap(Map<String, List<String>> ruleMap) {
    List<List<String>> ruleList = new ArrayList<>();
    cartesianProduct(ruleMap.values()).forEach(ruleList::add);
    return ruleList;
}

private static <T> Stream<List<T>> cartesianProduct(Collection<? extends Collection<T>> collections) {
    return cartesianProduct(new ArrayList<Collection<T>>(collections), Collections.emptyList());
}

private static <T> Stream<List<T>> cartesianProduct(List<? extends Collection<T>> collections, List<T> current) {
    return collections.isEmpty() ? Stream.of(current) : collections.get(0).stream().flatMap(e -> {
        List<T> list = new ArrayList<>(current);
        list.add(e);
        return cartesianProduct(collections.subList(1, collections.size()), list);
    });
}

Answer 1

下面是如何將Map<String,List<String>>轉換為List<Map<String,String>>的簡單示例：

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
public class StreamTest {
    @Test
    public void test() {
        var map = new HashMap<String, List<String>>();
        map.put("key1", Arrays.asList("value1", "value2", "value3"));
        map.put("key2", Arrays.asList("value4", "value5", "value6"));

        var list = map.entrySet().stream()
                .flatMap(e -> e.getValue().stream()
                        .map(v -> Map.of(e.getKey(), v)))
                .collect(Collectors.toList());

        log.info(list.toString());
    }
}

Answer 2

您可以首先將列表的元素表示為Map<String,String> ，並獲得stream 的地圖列表，然后通過順序求和內部地圖對以獲得笛卡爾積，將此 stream reduce為單個列表。

在線試用！

Map<String, List<String>> map = new LinkedHashMap<>();
map.put("Location Number", List.of("100", "500"));
map.put("Department Number", List.of("11", "22", "33"));
map.put("District Number", List.of("")); // NOT an empty list!
map.put("Preferred Language", List.of("en-US"));

List<Map<String, String>> list = map.entrySet().stream()
        .map(entry -> entry.getValue().stream()
                // list elements as Map<String,String>
                .map(str -> Map.of(entry.getKey(), str))
                // List<Map<String,String>>
                .collect(Collectors.toList()))
        // intermediate output
        .peek(System.out::println)
        // stream of lists to a single list
        .reduce((list1, list2) -> list1.stream()
                // combinations of inner maps
                .flatMap(map1 -> list2.stream()
                        // join entries of two maps
                        .map(map2 -> {
                            Map<String, String> mp =
                                    new LinkedHashMap<>();
                            mp.putAll(map1);
                            mp.putAll(map2);
                            return mp;
                        }))
                // list of combinations
                .collect(Collectors.toList()))
        // returns List<Map<String,String>
        // otherwise an empty list
        .orElse(Collections.emptyList());

// final output
list.forEach(System.out::println);

中級output：

[{Location Number=100}, {Location Number=500}]
[{Department Number=11}, {Department Number=22}, {Department Number=33}]
[{District Number=}]
[{Preferred Language=en-US}]

最終 output：

{Location Number=100, Department Number=11, District Number=, Preferred Language=en-US}
{Location Number=100, Department Number=22, District Number=, Preferred Language=en-US}
{Location Number=100, Department Number=33, District Number=, Preferred Language=en-US}
{Location Number=500, Department Number=11, District Number=, Preferred Language=en-US}
{Location Number=500, Department Number=22, District Number=, Preferred Language=en-US}
{Location Number=500, Department Number=33, District Number=, Preferred Language=en-US}

---

^{另請參閱：將 map 列表轉換為地圖列表}