Java 如何迭代值为列表的哈希映射的结果？

我创建了一个散列映射，它将组合三个参数的唯一键分组，即customer、sc和admin。我想创建一个带有服务器列表的唯一密钥列表。我已经实现了以下功能：

public static void main(String[] args) {

        String items = "customer1^sc1^admin1|server1~" +
                "customer1^sc1^admin1|server2~" +
                "customer1^sc1^admin1|server3~" +
                "customer2^sc1^admin1|server1~" +
                "customer3^sc1^admin1|server3~" +
                "customer3^sc1^admin1|server2~";

        // Set up raw data
        List<String> splitItems = Arrays.asList(items.split("\\s*~\\s*"));

        // Display raw data
        System.out.println("Raw List: " + items);

        // Create a hash map containing customer name as key and list of logs as value
        HashMap<String, List<String>> customerHashMap = new HashMap<>();

        // Loop through raw data
        for (String item : splitItems) {

            // Create new lists. One for customers and one for logs
            // List<String> customerList = new ArrayList<>();
            List<String> logList;

            String list[] = item.split("\\|");

            String customer = list[0];
            String log = list[1];

            logList = customerHashMap.get(customer);
            if (logList == null){
                logList = new ArrayList<>();
                customerHashMap.put(customer, logList);
            }

            logList.add(log);
            // System.out.println(logList);
        }

        // Print out of the final hash map. Customer "a" should only have "a" logs, customer "b" with "b", etc.
        System.out.println("");
        List<String> hashMapList = new ArrayList<String>();
        Iterator it = customerHashMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry pair = (Map.Entry) it.next();
            String output = pair.getKey() + "|" + pair.getValue().toString();
            hashMapList.add(output);
            it.remove();
        }

        String hashMapResultString = hashMapList.toString();
        String hashMapResultFormatted = hashMapResultString.replaceAll("[\\[\\]]", "");
        System.out.println(hashMapResultFormatted);

    }

现在我想使用哈希映射创建一个字符串，该字符串将被进一步解析（不要问lol）。因此，我将哈希映射的键和值设置为一个字符串，该字符串用唯一的分隔符

|

分隔它们。问题是，因为键是一个

列表

，所以在打印时，如果每个新的

键的值是一个包含多个项的列表，即
customer3^sc1^admin1 | server3，server2，
之后紧接着是
customer1^sc1^admin1 | server1，server2，server3
。我需要一个分隔符来分隔它们

我的理想输出如下所示：

customer2^sc1^admin1|server1~customer3^sc1^admin1|server3, server2~customer1^sc1^admin1|server1, server2, server3~...

我怎样才能做到这一点

更新：

customer2^sc1^admin1|server1, customer3^sc1^admin1|server3, server2, customer1^sc1^admin1|server1, server2, server3

这是我最终发现对我的特定问题有用的答案：

    StringBuilder s = new StringBuilder();
        for (Map.Entry<String, List<String>> entry : customerHashMap.entrySet()) {
            s.append(entry.getKey() + "|");
            List<String> list = entry.getValue();
            for (String item : list) {
                if (item != list.get(list.size() - 1)) {
                    s.append(item + "^");
                } else {
                    s.append(item);
                }
            }
            s.append("~");
        }
        System.out.println(s.toString());

StringBuilder s=new StringBuilder（）；
对于（Map.Entry:customerHashMap.entrySet（））{
s、 追加（entry.getKey（）+“|”）；
List=entry.getValue（）；
用于（字符串项：列表）{
if（item！=list.get（list.size（）-1））{
s、 附加（项目+“^”）；
}否则{
s、 附加（项目）；
}
}
s、 附加（“~”）；
}
System.out.println（s.toString（））；
您可以遍历地图的条目集：

StringBuilder s = new StringBuilder();
for(Map.Entry<String,List<String>> entry : map.entrySet()) {
   s.append(entry.getKey() + "\n");
   List<String> list = entry.getValue();
   for(String item : list) {
      s.append("   " + item + "\n");
   }
}
return s.toString();

这里发生的是：


我们得到一个
条目流…
将每个条目转换为
val1^v2^v3^…^valN | key
格式的字符串，即，我们将
流
映射为
流
最后一个
collect（）
使用
~
作为分隔符，将字符串流合并为单个字符串
您似乎误解了，
HashMap
这里是列表中的值，而不是键（如标题所述）对不起。打字错误。你会发现，在问题本身中，我更为一致。我认为这里的解决方案是在其他字符出现后删除下一个字符，即删除下一个
，
，在每个
~
@santafebound之后。你说的是关于逗号连接列表的一般问题。最好不要添加不需要的分隔符，而不是先添加它们，然后删除它们。看一看StringJoiner的源代码——它们做得很好。@santafebound但如果你只是想得到效果，就用StringJoiner而不是自己写——这就是它的目的。@santafebound用花哨的schmancy流导向选项进行了更新。这个新方法在Java 1.5中有等价物吗？
 String encoded = map.entrySet().stream()
     .map( entry -> entry.getValue().stream()
               .collect(Collectors.joining("^"))
             + "|" + entry.getKey())
     .collect(Collectors.joining("~"));