如何将 HashMultiset<String> 转换为 Map<String,Integer>

Question

除了迭代Set 中的所有条目之外，是否有一些技巧可以将HashMultiset<String> 转换为Map<String,Integer>？
更新：Integer 应该表示多重集中 String 的计数。

Answer 1

您可以使用Maps.asMap。使用 lambda 表达式 (Java 8) 它将是一个单行：

Maps.asMap(multiset.elementSet(), elem -> multiset.count(elem));

在 Java 7 及以下版本中：

final Multiset<String> multiset = HashMultiset.create();
Map<String, Integer> freqMap = Maps.asMap(multiset.elementSet(), 
    new Function<String, Integer>() {
        @Override
        public Integer apply(String elem) {
            return multiset.count(elem);
        }
    });

Answer 2

更新到 java 8，这是我发现的最佳答案（基于其他答案）：

public static <E> Map<E, Integer> convert(Multiset<E> multiset) {
    return multiset.entrySet().stream().collect(
        Collectors.toMap(x->x.getElement(),x->x.getCount()));
}

或：

public static <E> Map<E, Integer> convert(Multiset<E> multiset) {
    return multiset.entrySet().stream().collect(
        Collectors.toMap(Entry::getElement,Entry::getCount));
}

Answer 3

使用Eclipse Collections，您可以在Bag（又名Multiset）上使用toMapOfItemToCount 方法，这将返回一个Map，并在Bag 和Integer 计数中使用相同类型的键.

注意：我是 Eclipse 集合的提交者。

Answer 4

您可以简单地遍历条目并将元素和计数放入地图。

public class MultisetToMap {
  public static <E> Map<E, Integer> convert(Multiset<E> multiset) {
    Map<E, Integer> map = Maps.newHashMap();
    for (E e : multiset) {
      multiset.count(e);
      map.put(e, multiset.count(e));
    }

    return map;
  }
}

下面是（通过）JUnit 测试。

 @Test
  public void testConvert() {
    HashMultiset<String> hashMultiset = HashMultiset.create();

    hashMultiset.add("a");
    hashMultiset.add("a");
    hashMultiset.add("a");
    hashMultiset.add("b");
    hashMultiset.add("c");

    Map<String, Integer> map = MultisetToMap.convert(hashMultiset);
    assertEquals((Integer) 3, map.get("a"));
    assertEquals((Integer) 1, map.get("b"));
    assertEquals((Integer) 1, map.get("c"));
  }

Answer 5

如果你真的想避免循环遍历 Multiset 的条目，你可以创建一个 Map 的视图：

public class MultisetMapView<E> implements Map<E, Integer> {
  private Multiset<E> delegate;

  public MultisetMapView(Multiset<E> delegate) {
    this.delegate = delegate;
  }

  public int size() {
    return delegate.size();
  }

  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  public boolean containsKey(Object key) {
    return delegate.contains(key);
  }

  public boolean containsValue(Object value) {
    throw new UnsupportedOperationException();
  }

  public Integer get(Object key) {
    return delegate.count(key);
  }

  public Integer put(E key, Integer value) {
    return delegate.setCount(key, value);
  }

  public Integer remove(Object key) {
    int count = delegate.count(key);
    delegate.remove(key);
    return count;
  }

  public void putAll(Map<? extends E, ? extends Integer> m) {
    for (Entry<? extends E, ? extends Integer> entry : m.entrySet()) {
      delegate.setCount(entry.getKey(), entry.getValue());
    }
  }

  public void clear() {
    delegate.clear();
  }

  public Set<E> keySet() {
    return delegate.elementSet();
  }

  public Collection<Integer> values() {
    throw new UnsupportedOperationException();
  }

  public Set<java.util.Map.Entry<E, Integer>> entrySet() {
    Set<java.util.Map.Entry<E, Integer>> entrySet = Sets.newHashSet();
    for (E e : delegate) {
      delegate.count(e);
      entrySet.add(Maps.immutableEntry(e, delegate.count(e)));
    }

    return entrySet;
  }

}

在我的实现中，我拒绝实现containsValue 和values 方法，因为它们在上下文中没有用。如果需要，可以通过遍历条目并检查遇到的元素的count 来实现这些。

再一次，您可以在这个 JUnit 案例中看到这一点：

  @Test
  public void testConvert() {
    HashMultiset<String> hashMultiset = HashMultiset.create();

    hashMultiset.add("a");
    hashMultiset.add("a");
    hashMultiset.add("a");
    hashMultiset.add("b");
    hashMultiset.add("c");

    Map<String, Integer> map = new MultisetMapView<String>(hashMultiset);
    assertEquals((Integer) 3, map.get("a"));
    assertEquals((Integer) 1, map.get("b"));
    assertEquals((Integer) 1, map.get("c"));
  }

Answer 6

这是可能的，但只能使用反射，而且看起来很不安全。

    HashMultiset<String> hashMultiset = HashMultiset.create();

    hashMultiset.add("a");
    hashMultiset.add("a");
    hashMultiset.add("a");
    hashMultiset.add("b");
    hashMultiset.add("c");

    System.out.println(hashMultiset);

    Method method = hashMultiset.getClass().getSuperclass().getDeclaredMethod("backingMap");
    method.setAccessible(true);

    Map<String, Integer> map = (Map<String, Integer>) method.invoke(hashMultiset);

    System.out.println(map);

结果：

[b, c, a x 3]
{b=1, c=1, a=3}