Java 如何从地图中类似的键值前缀构建对象

首先，我用Java来写这个。 我有一张地图，上面有这样的键和值

 Key  = Value
"a.1" = "a1"
"a.2" = "a2"
"a.3" = "a3"
"b.1" = "b1"
"b.2" = "b2"
"b.3" = "b3"
"c.1" = "c1"
"c.2" = "c2"
"c.3" = "c3"

我需要做的是让它把所有的东西分开，然后制作，这样最终我就可以使用

someloop{
    new someObject(a1,b1,c1); // new someObject(a2,b2,c2);  // new someObject(a3,b3,c3);
}

---

我需要能够使其动态化，以便添加另一个前缀（d，e），并检查是否缺少或跳过了一个数字。

我省略了输入验证：

public static void buildObjects(Map<String, String> keyValuePairs) {
    List<List<String>> sortedValues = new ArrayList<>();
    // assuming keys are ending in a digit 1 through 9, add empty lists to sortedValues to hold values
    sortedValues.add(null); // index 0
    for (int index = 0; index <= 9; index++) {
        sortedValues.add(new ArrayList<>());
    }

    for (Map.Entry<String, String> pair : keyValuePairs.entrySet()) {
        String key = pair.getKey();
        int indexOfDot = key.indexOf('.');
        int suffix = Integer.parseInt(key.substring(indexOfDot + 1));
        sortedValues.get(suffix).add(pair.getValue());
    }
    for (List<String> list : sortedValues) {
        if (list != null && ! list.isEmpty()) {
            new SomeObject(list.toArray(new String[list.size()]));
        }
    }
}

publicstaticvoidbuildobjects（映射keyValuePairs）{
List sortedValues=new ArrayList（）；
//假设键以数字1到9结尾，将空列表添加到SortedValue以保存值
sortedValues.add（null）；//索引0
对于（int index=0；index我省略了输入验证：

public static void buildObjects(Map<String, String> keyValuePairs) {
    List<List<String>> sortedValues = new ArrayList<>();
    // assuming keys are ending in a digit 1 through 9, add empty lists to sortedValues to hold values
    sortedValues.add(null); // index 0
    for (int index = 0; index <= 9; index++) {
        sortedValues.add(new ArrayList<>());
    }

    for (Map.Entry<String, String> pair : keyValuePairs.entrySet()) {
        String key = pair.getKey();
        int indexOfDot = key.indexOf('.');
        int suffix = Integer.parseInt(key.substring(indexOfDot + 1));
        sortedValues.get(suffix).add(pair.getValue());
    }
    for (List<String> list : sortedValues) {
        if (list != null && ! list.isEmpty()) {
            new SomeObject(list.toArray(new String[list.size()]));
        }
    }
}

publicstaticvoidbuildobjects（映射keyValuePairs）{
List sortedValues=new ArrayList（）；
//假设键以数字1到9结尾，将空列表添加到SortedValue以保存值
sortedValues.add（null）；//索引0
对于（int index=0；index，如果更改SomeObject的构造函数以接受字符串列表，这可能会起作用：

 Map<String, String> map = new HashMap<>();
    map.put("a.1", "a1");
    map.put("a.2", "a2");
    map.put("a.3", "a3");
    map.put("b.1", "b1");
    map.put("b.2", "b2");
    map.put("b.3", "b3");
    map.put("c.1", "c1");
    map.put("c.2", "c2");
    map.put("c.3", "c3");

    Map<String, List<String>> grouped = map.entrySet().stream()
            .sorted(Comparator.comparing(Map.Entry::getKey))
            .collect(Collectors.groupingBy(
                    entry -> entry.getKey().split("\\.")[0],
                    HashMap::new,
                    Collectors.mapping(Map.Entry::getValue, Collectors.toList())));

    List<SomeObject> objects = grouped.values().stream().map(SomeObject::new).collect(Collectors.toList());

    System.out.println(objects);

Map Map=newhashmap（）；
地图放置（“a.1”、“a1”）；
地图放置（“a.2”、“a2”）；
地图放置（“a.3”、“a3”）；
地图放置（“b.1”、“b1”）；
地图放置（“b.2”、“b2”）；
地图放置（“b.3”、“b3”）；
地图放置（“c.1”、“c1”）；
地图放置（“c.2”、“c2”）；
地图放置（“c.3”、“c3”）；
Map group=Map.entrySet（）.stream（）
.sorted（Comparator.comparing（Map.Entry:：getKey））
.collect（收集器.groupingBy(
entry->entry.getKey（）.split（“\\”）[0]，
HashMap:：新建，
Collectors.mapping（Map.Entry:：getValue，Collectors.toList（））；
List objects=grouped.values（）.stream（）.map（SomeObject:：new）.collect（Collectors.toList（））；
System.out.println（对象）；
如果将某个对象的构造函数更改为接受字符串列表，这可能会起作用：

 Map<String, String> map = new HashMap<>();
    map.put("a.1", "a1");
    map.put("a.2", "a2");
    map.put("a.3", "a3");
    map.put("b.1", "b1");
    map.put("b.2", "b2");
    map.put("b.3", "b3");
    map.put("c.1", "c1");
    map.put("c.2", "c2");
    map.put("c.3", "c3");

    Map<String, List<String>> grouped = map.entrySet().stream()
            .sorted(Comparator.comparing(Map.Entry::getKey))
            .collect(Collectors.groupingBy(
                    entry -> entry.getKey().split("\\.")[0],
                    HashMap::new,
                    Collectors.mapping(Map.Entry::getValue, Collectors.toList())));

    List<SomeObject> objects = grouped.values().stream().map(SomeObject::new).collect(Collectors.toList());

    System.out.println(objects);

Map Map=newhashmap（）；
地图放置（“a.1”、“a1”）；
地图放置（“a.2”、“a2”）；
地图放置（“a.3”、“a3”）；
地图放置（“b.1”、“b1”）；
地图放置（“b.2”、“b2”）；
地图放置（“b.3”、“b3”）；
地图放置（“c.1”、“c1”）；
地图放置（“c.2”、“c2”）；
地图放置（“c.3”、“c3”）；
Map group=Map.entrySet（）.stream（）
.sorted（Comparator.comparing（Map.Entry:：getKey））
.collect（收集器.groupingBy(
entry->entry.getKey（）.split（“\\”）[0]，
HashMap:：新建，
Collectors.mapping（Map.Entry:：getValue，Collectors.toList（））；
List objects=grouped.values（）.stream（）.map（SomeObject:：new）.collect（Collectors.toList（））；
System.out.println（对象）；
“同时保持有序。”哦，你知道吗？如果你使用字符串（即字典顺序），那么“a.1”、“a.2”和“a.10”将被排序为“a.1”、“a.10”、“a.20”？我想保持有序其实并不重要。如果你不知道，你打算如何检测漏洞？前缀总是一个美国ASCII字母（a到z）？每个前缀总是有三个键值对吗？或者
SomeObject（）
接受varargs吗？您能解释一下拆分部分吗？创建一个所有值都以相同数字结尾的对象吗？“同时保持顺序。”oops。您知道如果使用字符串，“a.1”、“a.2”和“a.10”将被排序为“a.1”、“a.10”、“a.20”吗（即词典顺序）？我想保持它的顺序其实并不那么重要。如果你不这样做，你打算如何检测漏洞？前缀是否总是一个美国ASCII字母（a到z）？每个前缀总是正好有三个键值对？或者
SomeObject（）
accept varargs？你能解释一下拆分部分吗？创建一个所有值都以相同数字结尾的对象吗？或者如果你的
SomeObject（）
构造函数只是varargs，它仍然会接受一个数组：
List objects=grouped.values（）.stream（）.map（List->List.toArray（新字符串[List.size（）））.map（SomeObject:：new）。collect（Collectors.toList（））；
。或者如果您的
SomeObject（）
构造函数仅为varargs，它仍将接受数组：
List objects=grouped.values（）.stream（）.map（List->List.toArray（新字符串[List.size（）]）.map（SomeObject:：new.collector.toList（））；
。