Java 成对数组的二元矩阵

我在java中遇到以下问题：

我试图创建一个二进制矩阵，其中输入是一个成对数组

ArrayList<Pair<String, String>> inputArray = new ArrayList<Pair<String, String>>();

预期产出将是：

           value1   value2   value3   value4
argument1     1        1       0        1
argument2     0        1       0        1
argument3     1        1       1        0

我知道在这个论坛上有关于如何创建二进制数组的答案，但我没有找到任何关于如何创建一个成对数组的答案

提前感谢您的任何提示

输出

short[][] matrix = new short[rows][columns];

使用

映射

，从第一个映射中选择

参数

，在第二个映射中选择

值

，得到

0

或

1

ArrayList<Pair<String, String>> list = new ArrayList<>();
list.add(new Pair<>("ag1", "val1"));  list.add(new Pair<>("ag1", "val2"));
list.add(new Pair<>("ag1", "val4"));  list.add(new Pair<>("ag2", "val2"));
list.add(new Pair<>("ag2", "val4"));  list.add(new Pair<>("ag3", "val2"));
list.add(new Pair<>("ag3", "val2"));  list.add(new Pair<>("ag3", "val3"));

List<String> arguments = list.stream().map(Pair::getKey).distinct().collect(Collectors.toList());
List<String> values = list.stream().map(Pair::getValue).distinct().collect(Collectors.toList());

Map<String, Map<String,Integer>> map = new TreeMap<>();

for(String ag : arguments){
    map.putIfAbsent(ag, new TreeMap<>());

    for(String val : values){
        if(list.contains(new Pair<>(ag,val))){
            map.get(ag).put(val, 1);
        }else{
            map.get(ag).put(val,0);        
        }
    }

}
System.out.println(map);
//{ag1={val1=1, val2=1, val3=0, val4=1}, 
   ag2={val1=0, val2=1, val3=0, val4=1}, 
   ag3={val1=0, val2=1, val3=1, val4=0}}

---

下面是另一种使用分组模拟数据透视表的方法：

List<String> rights = inputArray.stream()
        .map(Pair::getRight)
        .distinct()
        .sorted()
        .collect(Collectors.toList());

List<Pair<String, Map<String, Boolean>>> mapping = inputArray.stream()
        .collect(Collectors.groupingBy(Pair::getLeft, 
                    Collectors.mapping(Pair::getRight, Collectors.toSet())))
        .entrySet().stream()
        .map(entry -> {
            Map<String, Boolean> values = new HashMap<>();

            rights.stream().forEach(v -> {
                values.put(v, entry.getValue().contains(v) ? Boolean.TRUE : Boolean.FALSE);
            });

            return Pair.of(entry.getKey(), values);
        }).collect(Collectors.toList());

结果:

            value1 | value2| value3| value4| 
argument1 |       1|      1|      0|      1|
argument2 |       0|      1|      0|      1|
argument3 |       1|      1|      1|      0|

---

对输出结构的要求？因此输出应该是：

short[]binaryMatrix=newshort[count（arguments）][count（values）]

您不能使用

short

数组，因为您将丢失“argument1”和“value1”字符串？或者您不介意保留字符串，只需要数组的0/1数组？这是使用

short[][]

的解决方案，如果需要保留字符串，请使用

Map

的解决方案？你似乎对一个解决方案没什么意见，这个解决方案只是提供了一个结构来保存你的价值观，你从来没有谈论过印刷，对吧，想想投票支持一些答案也可能

List<String> rights = inputArray.stream()
        .map(Pair::getRight)
        .distinct()
        .sorted()
        .collect(Collectors.toList());

List<Pair<String, Map<String, Boolean>>> mapping = inputArray.stream()
        .collect(Collectors.groupingBy(Pair::getLeft, 
                    Collectors.mapping(Pair::getRight, Collectors.toSet())))
        .entrySet().stream()
        .map(entry -> {
            Map<String, Boolean> values = new HashMap<>();

            rights.stream().forEach(v -> {
                values.put(v, entry.getValue().contains(v) ? Boolean.TRUE : Boolean.FALSE);
            });

            return Pair.of(entry.getKey(), values);
        }).collect(Collectors.toList());

rights.forEach(r -> System.out.print(r + " | "));
System.out.println();
mapping.forEach((key) -> {
    StringBuilder sb = new StringBuilder(key.getLeft() + " | ");
    rights.forEach(rr -> sb.append((key.getRight().get(rr) ? "      1" : "      0") + "|"));
    System.out.println(sb);
});

            value1 | value2| value3| value4| 
argument1 |       1|      1|      0|      1|
argument2 |       0|      1|      0|      1|
argument3 |       1|      1|      1|      0|