Java 使用hashmap对相似项进行分组

我有这样的输入

0    [0.327097, 0.326998, 0.0]
0    [1.056364, 0.601873, 0.0]
0    [1.273154, 1.656441, 0.0]
1    [1.48469, 0.095074, 0.0]
1    [1.061504, -0.768175, 1.0]

我需要把它们分类为

0 :  [ [0.327097, 0.326998, 0.0] ,[1.056364, 0.601873, 0.0], [1.273154, 1.656441, 0.0]]
1 :  [ [1.48469, 0.095074, 0.0], [1.061504, -0.768175, 1.0]]

我确实喜欢这个

但是我没有得到相同的输出。我的输出在重复

你能帮我一下吗

Map<String, Collection<String>> groupMap = new HashMap<String, Collection<String>>();
                   String[] subparts = finalline.split("\\[");    

                  String groupKey;
                  String value;

                  if (subparts.length == 1) {                                 
                      groupKey = null;
                      value = subparts[0];
                  }
                  else    if (subparts.length == 2) {                         
                      groupKey = subparts[0];
                      value = subparts[1];
                  }
                      else {
                      throw new IllegalArgumentException("Can not parse string");
                  }

                  Collection<String> groupContents = groupMap.get(groupKey);     
                  if (groupContents == null) {                                    
                      groupMap.put(groupKey, groupContents = new ArrayList<String>());
                  }
                  groupContents.add(value);                                    

                }

Map groupMap=newhashmap（）；
字符串[]子部分=finalline.split（“\\[”）；
字符串组键；
字符串值；
如果（子部分长度==1）{
groupKey=null；
值=子部分[0]；
}
如果（子部分长度==2）{
groupKey=子部分[0]；
值=子部分[1]；
}
否则{
抛出新的IllegalArgumentException（“无法解析字符串”）；
}
集合groupContents=groupMap.get（groupKey）；
如果（groupContents==null）{
put（groupKey，groupContents=newarraylist（））；
}
groupContents.add（value）；
}

组映射的值是另一个集合，因此您可以在外部循环中迭代该集合，如下所示

Map<String, Collection<String>> groupMap = new HashMap<String, Collection<String>>();
for(String key : groupMap.keySet()){
    System.out.println("Key: " + key);
    Collection<String> values =  groupMap.get(key);
    for(String value : values){
        System.out.println("value: " + value);
    }
}

Map groupMap=newhashmap（）；
for（字符串键：groupMap.keySet（））{
System.out.println（“Key:+Key”）；
集合值=groupMap.get（键）；
for（字符串值：值）{
System.out.println（“值：”+value）；
}
}

组映射的值是另一个集合，因此您可以在外部循环中迭代该集合，如下所示

Map<String, Collection<String>> groupMap = new HashMap<String, Collection<String>>();
for(String key : groupMap.keySet()){
    System.out.println("Key: " + key);
    Collection<String> values =  groupMap.get(key);
    for(String value : values){
        System.out.println("value: " + value);
    }
}

Map groupMap=newhashmap（）；
for（字符串键：groupMap.keySet（））{
System.out.println（“Key:+Key”）；
集合值=groupMap.get（键）；
for（字符串值：值）{
System.out.println（“值：”+value）；
}
}

Map groupMap=newhashmap（）；
对于（字符串s:groupMap.keySet（））{
for（字符串s1:groupMap.get）{
系统输出打印LN（s1）；
}
}

集合中的集合只意味着嵌套循环——就像二维数组一样； 对于（字符串s:groupMap.keySet（））{ for（字符串s1:groupMap.get）{ 系统输出打印LN（s1）； } }

---

集合中的集合只意味着嵌套循环——就像二维数组一样。

在

映射中循环条目的最有效方法如下所示：

Map<String, Collection<String>> groupMap = new HashMap<String, Collection<String>>();
for (Map.Entry<String, Collection<String>> entry : map.entrySet()) {
    System.out.println("Key: "+entry.getKey());
    for (String val : values) {
        System.out.printlnln("Value: "+entry.getValue());
    }
}

Map groupMap=newhashmap（）；
对于（Map.Entry:Map.entrySet（））{
System.out.println（“Key:+entry.getKey（））；
for（字符串值：值）{
System.out.printlnln（“Value:+entry.getValue（））；
}
}
在
地图中循环条目的最有效方法如下所示：

Map<String, Collection<String>> groupMap = new HashMap<String, Collection<String>>();
for (Map.Entry<String, Collection<String>> entry : map.entrySet()) {
    System.out.println("Key: "+entry.getKey());
    for (String val : values) {
        System.out.printlnln("Value: "+entry.getValue());
    }
}

Map groupMap=newhashmap（）；
对于（Map.Entry:Map.entrySet（））{
System.out.println（“Key:+entry.getKey（））；
for（字符串值：值）{
System.out.printlnln（“Value:+entry.getValue（））；
}
}
我建议改用“番石榴”中的一种

它有助于轻松处理从键到多个值的映射，并且是将键与任意多个值关联的通用方法

这里有一个例子

Multimap<String, String> map = HashMultimap.create();
map.put("1", "a");
map.put("1", "b");

map.put("2", "c");
map.put("2", "d");

这会给你

a
b 
c 
d

或者，如果希望键与值一起使用，则可以使用“entries（）”视图

如果您正在寻找一个简单的java解决方案

Map<String, List<String>> map = new HashMap<String, List<String>>();
// ... Some code to put values in the map
for(String key : map.keySet()){
    System.out.println("\nKey: " + key);
    List<String> values = map.get(key);
    for(String value : values) {
        System.out.println("Value: " + value);
    }
}

Map Map=newhashmap（）；
//…一些将值放入映射的代码
for（字符串键：map.keySet（））{
System.out.println（“\nKey:+key”）；
列表值=map.get（键）；
for（字符串值：值）{
System.out.println（“值：”+Value）；
}
}
我建议改用“番石榴”中的一种

它有助于轻松处理从键到多个值的映射，并且是将键与任意多个值关联的通用方法

这里有一个例子

Multimap<String, String> map = HashMultimap.create();
map.put("1", "a");
map.put("1", "b");

map.put("2", "c");
map.put("2", "d");

这会给你

a
b 
c 
d

或者，如果希望键与值一起使用，则可以使用“entries（）”视图

如果您正在寻找一个简单的java解决方案

Map<String, List<String>> map = new HashMap<String, List<String>>();
// ... Some code to put values in the map
for(String key : map.keySet()){
    System.out.println("\nKey: " + key);
    List<String> values = map.get(key);
    for(String value : values) {
        System.out.println("Value: " + value);
    }
}

Map Map=newhashmap（）；
//…一些将值放入映射的代码
for（字符串键：map.keySet（））{
System.out.println（“\nKey:+key”）；
列表值=map.get（键）；
for（字符串值：值）{
System.out.println（“值：”+Value）；
}
}
迭代地图条目的最佳和最有效的方法是：

Map<String, Collection<String>> map;
for (Map.Entry<String, Collection<String>> entry : map.entrySet()) {
    System.out.print(entry.getKey()+":");
    for (String str : entry.getValue())
       System.out.println(str);
}

Map；
对于（Map.Entry:Map.entrySet（））{
System.out.print（entry.getKey（）+“：”）；
for（字符串str:entry.getValue（））
系统输出打印项次（str）；
}

此代码将生成您请求的输出

请注意，在任何时候都不会查找键。当您迭代条目集时，您可以直接访问（键入的）键和（键入的）值。
迭代映射条目的最佳和最有效方法是：

Map<String, Collection<String>> map;
for (Map.Entry<String, Collection<String>> entry : map.entrySet()) {
    System.out.print(entry.getKey()+":");
    for (String str : entry.getValue())
       System.out.println(str);
}

Map；
对于（Map.Entry:Map.entrySet（））{
System.out.print（entry.getKey（）+“：”）；
for（字符串str:entry.getValue（））
系统输出打印项次（str）；
}

此代码将生成您请求的输出

请注意，在任何时候都不会查找键。当您迭代条目集时，您可以直接访问（键入的）键和（键入的）值