Java HashMap：使用公共键添加值并打印出来

我有一个文件，它的字符串格式是

key/value

pair like people and count，例如

"Reggy, 15"
"Jenny, 20"
"Reggy, 4"
"Jenny, 5"

在输出中，我应该根据键对所有计数值求和，所以对于我们的示例，输出是

"Reggy, 15"
"Jenny, 20"
"Reggy, 4"
"Jenny, 5"

“雷吉，19岁” “珍妮，25岁”

我的做法如下：

读取每一行，并使用扫描器和

，

作为分隔符获取每一行的键和计数

现在看看键在if之前是否已经存在，然后将currentValues添加到previousValues，若不存在，则将currentValues作为HashMap的值 示例实现：

public static void main(final String[] argv) {
    final File file = new File("C:\\Users\\rachel\\Desktop\\keyCount.txt");

    try {
        final Scanner scanner = new Scanner(file);

        while (scanner.hasNextLine()) {
            if (scanner.hasNext(".*,")) {
                String key;
                final String value;

                key = scanner.next(".*,").trim();

                if (!(scanner.hasNext())) {
                    // pick a better exception to throw
                    throw new Error("Missing value for key: " + key);
                }

                key = key.substring(0, key.length() - 1);
                value = scanner.next();

                System.out.println("key = " + key + " value = " + value);
            }
        }
    } catch (final FileNotFoundException ex) {
        ex.printStackTrace();
    }
}

我不清楚的部分是如何划分键/值对，同时读取它们并在此基础上创建HashMap

---

此外，该方法是否是最佳方法，或者是否有更有效的方法来提高性能

因为这几乎肯定是一个学习练习，所以我将远离编写代码，让您享受所有乐趣

创建一个

HashMap

。每次看到键/值对时，请检查哈希映射是否具有该键的值（使用“containsKey（key）”）。如果是，则使用

get（key）

获取旧值，添加新值，然后使用

put（key，newValue）

将结果存储回去。如果钥匙还不存在，请使用

put

再次添加一个新钥匙。如果

字符串值

（请使用

Integer.valueOf（value）

），请不要忘记输出

int

---

就优化而言，此时的任何优化都是不成熟的：它甚至不起作用！但是，很难获得比单个循环快得多的速度，这也相当简单。

对于阅读，我个人使用：

Scanner.nextLine（）

Map<String, Long> map = new HashMap<String, Long>();

while (scanner.hasNextLine()) {
        if (scanner.hasNext(".*,")) {
            ....
            if(map.containsKey(key))
                map.put(key, map.get(key) + Long.valueOf(value));
            else
                map.put(key, Long.valueOf(value));
        }
    }

Map Map=newhashmap（）；
while（scanner.hasNextLine（））{
if（scanner.hasNext（“.*”）{
....
if（地图容器（图例））
map.put（key，map.get（key）+Long.valueOf（value））；
其他的
map.put（key，Long.valueOf（value））；
}
}
拆分值的最简单方法：

    BufferedReader reader =  new BufferedReader(new FileReader(file));
    Map<String, Integer> mapping = new HashMap<String,Integer>();

    String currentLine;
    while ((currentLine = reader.readLine()) != null) {

        String[] pair  = currentLine.split(",");

         if(pair.length != 2){ //could be less strict
            throw new DataFormatException();
         }

         key = pair[0];
         value = Integer.parseInt(pair[1]);
         if(map.contains(key)){
             value +=  map.get(key);
         }
         map.put(key,value);
    }

BufferedReader=newbufferedreader（newfilereader（file））；
Map mapping=newhashmap（）；
串电流线；
while（（currentLine=reader.readLine（））！=null）{
字符串[]对=currentLine.split（“，”）；
如果（pair.length！=2）{//可能不那么严格
抛出新的DataFormatException（）；
}
密钥=对[0]；
value=Integer.parseInt（对[1]）；
if（映射包含（键））{
value+=map.get（键）；
}
map.put（键、值）；
}

就性能而言，这很可能不是最有效的方法，但非常简单
Scanner
通常用于解析，但这里的解析看起来并不复杂，只是字符串的一部分
 一种时间复杂度为O（n）的新型清洁溶液。此解决方案绕过了某种阵列

 public class Solution {

    public static void main(String[] args) {
    // Anagram
            String str1 = "School master";
            String str2 = "The classroom";


            char strChar1[] = str1.replaceAll("[\\s]", "").toLowerCase().toCharArray();
            char strChar2[] = str2.replaceAll("[\\s]", "").toLowerCase().toCharArray();

            HashMap<Character, Integer> map = new HashMap<Character, Integer>();

            for (char c : strChar1) {
                if(map.containsKey(c)){
                    int value=map.get(c)+1;
                    map.put(c, value);
                 }else{
                     map.put(c, 1);
                 }

            }

            for (char c : strChar2) {
                if(map.containsKey(c)){
                    int value=map.get(c)-1;
                    map.put(c, value);
                 }else{
                     map.put(c, 1); 
                 }
            }

            for (char c : map.keySet()) {
                if (map.get(c) != 0) {
                    System.out.println("Not anagram");
                }
            }
                    System.out.println("Is anagram");
        }
    }

公共类解决方案{
公共静态void main（字符串[]args）{
//字谜
字符串str1=“学校校长”；
String str2=“教室”；
char strChar1[]=str1.replaceAll（“[\\s]”，“”）。toLowerCase（）.toCharArray（）；
char strChar2[]=str2.replaceAll（“[\\s]”，“”）。toLowerCase（）.toCharArray（）；
HashMap=newHashMap（）；
for（字符c:strChar1）{
if（图c）{
int value=map.get（c）+1；
map.put（c，值）；
}否则{
图.put（c，1）；
}
}
for（字符c:strChar2）{
if（图c）{
int value=map.get（c）-1；
map.put（c，值）；
}否则{
图.put（c，1）；
}
}
for（char c:map.keySet（））{
如果（map.get（c）！=0）{
System.out.println（“非字谜”）；
}
}
System.out.println（“是字谜”）；
}
}
公共地图合并地图（@NonNull final-Map-mapOne，
@非空最终映射（映射二）{
返回Stream.of（mapOne.entrySet（），mapTwo.entrySet（））
.flatMap（集合：：流）
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue，Integer:：sum））；
}
您是否尝试过
java.util.HashMap#containsKey（），put（），get（）
？它是“伪代码”：-）应该拆分（“，”），因为它需要一个字符串。为什么长，当然数字看起来像年龄。不应该担心超过整数的值，比如年龄？那么这两个雷吉和珍妮就不是同一个人了：-）这是完全不同的情况。此外，
看起来似乎不是一个好的参数。但是，这是正确的，应该明智地选择。我知道实现的这一部分，但我遇到的问题是在中读取键/值对数据时。@Rachel如果您使用
扫描仪
读取行，然后使用
split
查看演示。