Question

我在Java中遇到以下问题：

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

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

所以可以这样说：

[(argument1, value1), 
 (argument1, value2), 
 (argument1, value4),
 (argument2, value2), 
 (argument2, value4), 
 (argument3, value1),
 (argument3, value2),
 (argument3, value3),]

预期输出为：

           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];

Answer 1

使用Map<String, Map<String,Integer>>，从第一个地图中选择argument，第二个地图中，选择value并获得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}}

在short[][]操作上使用stream，只需添加sorted()操作即可确保顺序不变。它将遍历不同的arguments和values，如果初始列表中有对应的Pair，它将把好索引设置为1，否则0

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().sorted().collect(Collectors.toList());
List<String> values = list.stream().map(Pair::getValue).distinct().sorted().collect(Collectors.toList());

short[][] res = new short[arguments.size()][values.size()];      

for(int ag = 0 ; ag<arguments.size() ; ag++){
    for(int val = 0 ; val<values.size() ; val++){  
        if(list.contains(new Pair<>(arguments.get(ag),values.get(val)))){
            res[ag][val] = 1;
        }else{
            res[ag][val] = 0;        
        }
    }    
}
System.out.println(Arrays.deepToString(res)); 
// [[1, 1, 0, 1], [0, 1, 0, 1], [0, 1, 1, 0]]

Answer 2

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

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|

对数组中的二进制矩阵

2 个答案: