代码之家 › 专栏 › 技术社区 › Awin

使用流和过滤器遍历多个列表并获取字符串

stream filter parsing string java

Awin · 技术社区 · 2 年前

我有两个列表和两个地图,如下所示:

List <String> codes = new ArrayList<>();
List <String> year = new ArrayList<>()


Map<String,Map<String,String> map1 = new HashMap<>();
Map<String,Map<String,String> map2 = new HashMap<>();


codes = [abc,def];
year = [2000,2001]
map1 = {abc={2000=0,2001=1, },def={2000=0.1,2001=0.3, }}

map2 = { abc={2000=0.1,2001=0.2, }}, def={2000=7.8,2001=5.4 }}

本质上,我想制作一个字符串,以这种格式得到它,在这种格式中,我遍历了唯一列表,年份列表以这种格式制作,顺序基于年份,如下所示:

String s = abc,2000,0,0.1, def,2000,0.1,7.8, abc,2001,1,0.2  def,2001,0.3,5.4

我使用double for循环来实现它,这样会使运行时变慢:

for (int i=0; i<codes.size();i++){


for (int j=0;j<year.size();j++){

String s = codes.get(i) + â,â + years.get(j) + â,â + map1.get(codes.get(i).years.get(j)) + â,â + map2.get(codes.get(i).years.get(j))

}


}

有没有办法避免使用for循环,并可能像上面那样使用流和过滤器来解析字符串?

0 回复 | 直到 2 年前

Reilas 2 年前

“…从本质上讲,我想制作一个字符串,以这种格式获得它,在这种格式中,我遍历了唯一列表,年份列表以这种格式制作,顺序基于年份,如下所示:…”

它看起来像是由…订购的年首先,然后代码 .

你必须迭代年只需检查两者 地图1 和 微管相关蛋白2 当你建造一串 .

Map<String, List<Map<Integer, Number>>> map1
    = Map.of("abc", List.of(Map.of(2000, 0), Map.of(2001, 1)),
             "def", List.of(Map.of(2000, 0.1), Map.of(2001, 0.3)));
Map<String, List<Map<Integer, Number>>> map2
    = Map.of("abc", List.of(Map.of(2000, 0.1), Map.of(2001, 0.2)),
             "def", List.of(Map.of(2000, 7.8), Map.of(2001, 5.4)));

String[] codes = { "abc", "def" };
int[] years = { 2000, 2001 };

for (int year : years) {
    for (Map.Entry<String, List<Map<Integer, Number>>> entryA : map1.entrySet()) {
        for (Map<Integer, Number> valueA : entryA.getValue()) {
            if (valueA.containsKey(year)) {
                System.out.printf("%s,%d,%s,", entryA.getKey(), year, valueA.get(year));
                for (Map.Entry<String, List<Map<Integer, Number>>> entryB : map2.entrySet()) {
                    if (entryB.getKey().equals(entryA.getKey())) {
                        for (Map<Integer, Number> valueB : entryB.getValue()) {
                            if (valueB.containsKey(year)) {
                                System.out.printf("%s,", valueB.get(year));
                                break;
                            }
                        }
                    }
                }
                break;
            }
        }
        System.out.print(" ");
    }
}

输出

abc,2000,0,0.1, def,2000,0.1,7.8, abc,2001,1,0.2, def,2001,0.3,5.4,

M. Justin Marwan Alsabbagh 2 年前

// "abc,2000,0,0.1, def,2000,0.0,7.8, abc,2001,1,0.2, def,2001,0.3,5.4"
String strings = year.stream()
        .flatMap(y -> codes.stream()
                .map(c -> "%s,%s,%s,%s".formatted(
                        c, y, map1.get(c).get(y), map2.get(c).get(y))))
        .collect(Collectors.joining(", "));

这会随着时间的推移而流动,每年都会在代码上流动。每个年份/代码组合都用逗号分隔。最后,流的每个元素都用逗号空格分隔符连接成一个字符串。