6

有没有简单的方法来获取存在相同值的键？或者更重要的是，我怎样才能获得相同值多次出现的次数？

考虑哈希图：

1->A
2->A
3->A
4->B
5->C
6->D
7->D

这里相同值不止一次发生了 3 次（A 两次，D 一次）。那（3）是我想要的回报。

我可以通过 keyset/map.values() 列表遍历哈希图，但这样做似乎很麻烦。有什么建议或解决方案吗？

编辑： 我的上下文是，我正在开发一个时间表生成器。时隙的数据结构是

{String day-hour, HashMap<String,Event> Rooms}

在一天的时间里，一些 Event-s 被分配在房间地图上。在检查解决方案的适用性时，我需要知道是否在同一小时内为一名员工分配了多个事件。因此，我想通过值 Event.getStaff() 检查房间地图中有多少违规行为。

编辑： 这里的值是对象，我不想计算相同对象的出现次数，而是对象的字段。事件对象有一个现场工作人员，我需要计算工作人员的多次出现。

4

5 回答 5

5

我可以通过 keyset/map.values() 列表遍历哈希图，但这样做似乎很麻烦。

好吧，它效率低下，但是您对此无能为力，因为没有某种多映射来存储值到键的反向映射。

不过，如果您使用Guava ，它在代码方面并不一定很麻烦：

Multiset<String> counts = HashMultiSet.create(map.values());
for (Multiset.Entry<String> entry : counts.entrySet) {
  if (entry.getCount() > 1) {
    System.out.println(entry.getElement() + ": " + entry.getCount());
  }
}
于 2012-11-07T12:17:42.810 回答
3

这是我认为的好方法：

int freq = Collections.frequency(map.values(), "A");

为您的示例返回“3”。干杯!

编辑：对不起，我在第一次尝试时误解了这个问题，这应该可以解决问题：

int k = 0;
Set<String> set = new HashSet<String>(map.values());
for (String s : set) {
   int i = Collections.frequency(map.values(), s);
   k += i > 1 ? i - 1 : 0;
}

但是，您仍然无法检索实际密钥。但这不是最重要的，对吧？

于 2012-11-07T12:21:17.713 回答
1

怎么样（扩展乔恩的答案）

Multiset<V> counts = HashMultiSet.create(map.values());
Predicate<Map.Entry<K,V>> pred = new Predicate<Map.Entry<K,V>>(){
   public boolean apply(Map.Entry<K,V> entry){
       return counts.count(entry.getValue()) > 1;
   }
}
Map<K,V> result = Maps.filterEntries(map, pred);

这将产生一个映射，其中每个键都映射到一个重复的值。

这个答案只需要解决问题的第一部分（“不太重要的部分”），以获得具有重复值的键。

于 2012-11-07T12:31:31.123 回答
0

我不知道上下文，但如果你使用多图怎么办：

Map<String, List<Integer>>

所以这样你的地图看起来像这样：

A->1, 2, 3
B->4
C->5
D->6, 7
于 2012-11-07T12:18:42.823 回答
0

您可以围绕 (Hash)Map 创建一个包装类，并装饰 put()-remove() 方法来维护另一个映射，其中原始 Map 的值是键，值是出现的次数。然后你只需要实现方法来查询......

然而，这相当棘手！您必须小心不要再链接到不在地图中的对象...这可能会导致内存泄漏！

此外，必须考虑空值容差......

public static class MyCountingMap<K,V> implements Map<K,V> {
  private final Map<K,V> internalMap;
  //hashmap tolerates null as a key!
  private final Map<V,Long> counterMap = new HashMap<V, Long>();

  public MyCountingMap(Map<K, V> internalMap) {
    super();
    this.internalMap = internalMap;
  }


  @Override
  public V put(K key, V value) {
    boolean containedOriginally = internalMap.containsKey(key);

    V origValue = internalMap.put(key, value);

    updateCounterPut(containedOriginally, origValue, value);

    return origValue;
  }

  @Override
  public void putAll(Map<? extends K, ? extends V> m) {
    //now this is the awkward part...
    //this whole thing could be done through a loop and the put() method, 
    //but I'd prefer to use the original implementation...
    for(Map.Entry<? extends K, ? extends V> entry :m.entrySet()) {
      boolean containedOriginally = internalMap.containsKey(entry.getKey());
      V origValue = internalMap.get(entry.getKey());
      updateCounterPut(containedOriginally, origValue, entry.getValue());
    }


    internalMap.putAll(m);
  }

  // this method updates the counter
  private void updateCounterPut(boolean containedOriginally, V origValue, V newValue) {
    //if it was in the map, and it is different than the original, decrement 
    if(containedOriginally && isDifferent(origValue, newValue)) 
    {
      decrement(origValue);
    }

    //if it was NOT in the map, or the value differs
    if(!containedOriginally || isDifferent(origValue, newValue)) {
      increment(newValue);
    }
  }

  // nothing special, just nicer to extract this to a method. Checks if the two values are the same or not.
  private static boolean isDifferent(Object origValue, Object newValue) {
    return ((origValue==null && newValue!=null) || !(origValue!=null && origValue.equals(newValue)));
  }

  //this method returns the counter value for the map value
  public Long getValueCount(V value) {
    return counterMap.get(value);
  }

  @Override
  public V remove(Object key) {
    V toReturn = internalMap.remove(key);
    if(toReturn!=null) {
      decrement(toReturn);
    }
    return toReturn;
  }

  private void increment(V value) {
    Long count = counterMap.get(value);
    if(count == null) {
      count = 0L;
    }
    counterMap.put(value, count+1);
  }

  private void decrement(V value) {
    Long count = counterMap.get(value);
    if(count == null) {
      count = 0L;
    }

    //last! Have to remove reference to prevent memory leak!!
    if(count == 1L) {
      counterMap.remove(value);
    } else {
      counterMap.put(value, count-1);
    }

  }
  //... boring wrapper methods ...
  public void clear() { internalMap.clear(); }
  public boolean containsKey(Object key) { return internalMap.containsKey(key); }
  public boolean containsValue(Object value) { return internalMap.containsValue(value);   }
  public Set<Entry<K, V>> entrySet() { return internalMap.entrySet();    }
  public V get(Object key) { return internalMap.get(key); }
  public boolean isEmpty() { return internalMap.isEmpty(); } 
  public Set<K> keySet() { return internalMap.keySet(); }
  public int size() { return internalMap.size(); }
  public Collection<V> values() { return internalMap.values(); }
}
于 2012-11-07T12:19:02.057 回答