HashMap - contains 和 get 方法不应该一起使用

Question

我在一次采访中得到了以下问题。

我得到了一个这样的字符数组：

char[] characters = {'u', 'a', 'u', 'i', 'o', 'f', 'u'};

我需要获取每个字符的不同字符和计数：

u = 3
a = 1
i = 1
o = 1
f = 1

所以我用 Java 回答了以下代码：

HashMap<Character, Integer> map = new HashMap<Character, Integer>();
int i = 1;
for (char c : characters) {             
    if (map.containsKey(c)) {
        int val = map.get(c);
        map.put(c, ++val);
    } else map.put(c, i);
}

面试官是一名解决方案架构师。他问我为什么在这里同时使用containsKey() 和get() 方法，并指出使用这两种方法是多余的。他的观点是什么？我在这里做错了什么？我的代码会导致性能问题等吗？

Answer 1

你可以像这样编写你的 for 循环 -

for (char c : characters) {             

   Integer val = map.get(c);
   if (null != val){
      map.put(c, ++val);
   } else {
      map.put(c, 1);
   }
}  

注意：我已将 int 修改为 Integer 以便我可以对照 null 检查它你声明的Integer 变量val。否则val 将是null。所以我认为你不需要使用Map.containsKey() 方法。

Answer 2

您的代码是多余的，因为 get 和 containsKey 的工作几乎相同。您可以检查 get 是否返回空值，而不是调用 containsKey。

代码可以简化为：

HashMap<Character, Integer> map = new HashMap<Character, Integer>();
for (char c : characters) {   
    Integer val = map.get(c);          
    if (val == null)
        val = 0;
    map.put(c,++val);
}

Answer 3

for (char c : characters) {   
     Integer val = map.get(c);
     if(val != null){
        map.put(c, ++val); 
     }else{
        map.put(c, 1);
     }
 }

这可能是最好的方法

函数 get 和 contains 都做同样的工作...

通过使用get函数而不是同时使用它的好处

使用 get 函数时在此处检查 null 值。 通过避免这两个调用可以提高性能。

注意：在这种情况下，性能可能没有任何改善，但在另一种情况下，数据量会很大。

Answer 4

如果您想在 Map 中计算字符数，我通常会这样做。

Map<Character, Integer> map = new HashMap();
for (char c: cs) {
    Integer iCnt = map.get(c);
    if (iCnt ==  null) {
        map.put(c, 1);                
    } else {
        map.put(c, ++iCnt);
    }
}

Map.containsKey(key) 会从 map 中检查指定的 key，这与 Map.get(key) 非常相似。在您的代码中，您同时调用“containsKey”和“get”方法，这意味着您将通过条目两次，这可能会导致性能问题。

Answer 5

问题在于 containskey 必须遍历 Map 的整个条目才能获取密钥（迭代 1）。下面是 containsKey 的代码。

public boolean containsKey(Object key) {
    return getEntry(key) != null;
}
final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }

    int hash = (key == null) ? 0 : hash(key);
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

现在 get('') 必须再次迭代以获取键映射的值（迭代 2）。 get 的代码也调用 getEntry，如下所示。

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

当不需要时，您不必要地遍历条目集 2 次，因此存在性能问题。 @Eran 在答案中给出了最好的方法。

Answer 6

让我们从您的代码开始，然后开始减少它。

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

for (char c : characters)
{             
    if (map.containsKey(c))
    {
        int val = map.get(c);
        map.put(c, ++val);
    }
    else map.put(c, i);
}

我要做的第一件事是使用 Java 7 菱形运算符，并删除变量 i

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

for (char c : characters)
{
    if (map.containsKey(c))
        map.put(c, ++map.get(c));
    else
        map.put(c, 1);
}

这是我的第一步，我们删除了变量i，因为它始终为1，并且在执行期间不会改变。我还精简了声明并将map.get 调用为map.put 调用。现在，当我们看到时，我们对 map 方法进行了三个调用。

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

for (char c : characters)
{
    Integer i = map.get(c);

    if (i == null) i = 0;

    map.put(c, ++i);
}

这是最好的方法，也是@Eran 在上面的答案中所说的。希望此细分对您有所帮助。

Answer 7

架构师的意思是get和containsKey的成本是一样的，可以累计成一张支票：

Integer val = map.get(c);
if (val != null) {
  ...
} else {
  ...
}

但我想知道为什么架构师只关心这一点，因为还有更多需要改进的地方：

• 通过接口引用对象（Effective Java 2nd Edition，Item 52）
• 从 Java 1.7 开始，您可以使用菱形运算符
• 累积字符的自动装箱操作
• 如果您使用AtomicInteger（或任何其他可修改的数字类）而不是Integer，您甚至可以将get 与puts 之一合并

所以从我的角度来看，使用 HashMap 时的最佳性能将提供：

Map<Character, AtomicInteger> map = new HashMap<>();
for (Character c : characters) {
    AtomicInteger val = map.get(c);
    if (val != null) {
        val.incrementAndGet();
    } else {
        map.put(c, new AtomicInteger(1));
    }
}

如果您的字符范围很小（并且事先知道），您可以使用 int 数组进行计数。这将是所有可能的解决方案中最快的：

char firstCharacter = 'a';
char lastCharacter = 'z';
int[] frequency = new int[lastCharacter - firstCharacter + 1];
for (char c : characters) {
  frequency[c - firstCharacter]++;
}

Answer 8

从 Java 8 开始，您甚至可以执行以下操作：

final Map<Character, Integer> map = new HashMap<>();
for (char c : characters)
    map.merge(c, 1, Integer::sum);

---

请注意，您使用此解决方案进行了大量装箱和拆箱。这应该不是问题，但最好能意识到这一点。

上面的代码实际上做了什么（即手动装箱和拆箱）：

for (char c : characters)
    map.merge(
        Character.valueOf(c),
        Integer.valueOf(1),
        (a, b) -> Integer.valueOf(Integer.sum(a.intValue(), b.intValue())));

Answer 9

嗯，我也是一名系统架构师，我认为您的代码没有任何问题，除了可能没有大括号 - 您通常应该始终使用它们。我认为这很好：

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

我个人会这样写，和你自己的版本很相似：

for (char c : characters) {
    int val = map.containsKey(c) ? map.get(c) : 0;
    map.put(c, ++val);
}

为什么同时使用 containsKey() 和 get() ？好吧，如果您只打算使用get()，那么您需要以某种方式进行空检查。阅读代码的其他人哪个更清楚，if (map.containsKey(c)) 或 if (val != null)？实际差别很小。

哈希查找是O(log N)，因此调用get() 和 containsKey() 会导致两次查找而不是一次。可能会使用非常大的数据集运行，那么这将是相关的。

最后，如果没有containtsKey() 检查，int val = map.get(c); 第一次会抛出 npe，因此您需要改用 Integer val = map.get(c);。哪个更清晰、更安全 - int val 或 Integer val？我认为让自动装箱来做这件事并使用int val 并没有错，而且我通常尽可能在对象上使用原始类型，尽管对于int 和Integer 可能有很多不同的意见。

Answer 10

另一个我还没有看到的 Java 8 解决方案：

Character[] characters = {'u', 'a', 'u', 'i', 'o', 'f', 'u'};
Map<Character, Integer> result = Arrays.asList(characters)
        .stream()
        .collect(Collectors.groupingBy(Function.identity(), Collectors.summingInt(c -> 1)));

它确实需要使用盒装类型 Character，不过 -- Arrays.asList 不能很好地与 char[] 配合使用，并且 Arrays.stream() 没有 char[] 的重载。

Answer 11

的确，答案很简单。包含方法检查元素是否存在于每次循环中的集合中。因此，集合越大，对每个下一个元素执行检查的时间就越长。包含对于散列集合很有用，其中不可能通过索引获取元素。但是对于这样的意图需要重写 hashCode 并且等于正确。在这种情况下，包含将花费 O(1)。