如何计算MultiMap中每个值的出现次数？ （Java）的

Question

I have Multimap , which contains two strings. Example:

1 = [key,car],  
2 = [key,blue],
3 = [key,car]

Multimap definition (I am using Guava library):

ListMultimap<Integer, String> map_multi = ArrayListMultimap.create(); 

And this is how I put values in MultiMap:

for (int i = 0; i < list.size(); i++) {
        if (i + 1 < list.size()) {

            multimap.put(i,(String) list.get(i));
            multimap.put(i,(String) list.get(i+1));

        } else if (i + 1 == list.size()) {
        }
    }      

I want to count the occurrences of the same value inside the multimap.

So the result should be 2 if i count how many values [key,car] are (per example I have given above) in my multimap:

• occurrences of [key,car] = 2
• occurrences of [key,blue] = 1

I have also tried to implement this with multi value HashMap and I was counting it with this, way ( Storage is class where I store two string values inside object):

B = Collections.frequency(new ArrayList<Storage>(map.values()), map.get(number));

But I don't get the right results.

Answer 1

You can achieve what you want by creating a map that has your multimap values as the keys and the count as the value:

Map<Collection<String>, Long> result = map_multi.asMap().values().stream()
    .collect(Collectors.groupingBy(v -> v, Collectors.counting()));

Here I've used Guava's Multimap.asMap method to get a view over the original multimap, then collected the values into a new map.

Another way, without streams:

Map<Collection<String>, Integer> result = new HashMap<>();
map_multi.asMap().values().forEach(v -> result.merge(v, 1, Integer::sum));

This uses the Map.merge method to accumulate equal values by counting its occurrences.

Answer 2

Please try this code. map_multi.get(key).size() is your answer.

ListMultimap<Integer, String> map_multi = ArrayListMultimap.create();
map_multi.put(1, "car");
map_multi.put(2, "blue");
map_multi.put(3, "apple");
map_multi.put(1, "car");

for (Integer key : map_multi.keySet()) {
    System.out.println(map_multi.get(key).get(0) + " occurances: " + map_multi.get(key).size());
}

Output:

car occurances: 2
blue occurances: 1
apple occurances: 1

Answer 3

So the first step is to create a Map<Integer, List<String>> from your ListMultimap . You can do this in the following way:

Map<Integer, List<String>> collect = map_multi.entries()
            .stream()
            .collect(Collectors.groupingBy(Map.Entry::getKey,
                     Collectors.mapping(Map.Entry::getValue,
                                        Collectors.toList())));

Then let's say you have a List<String> with car and key in it. Example:

 List<String> myList = List.of("key", "car"); // java 9

You just iterate through the values() of the map and check if myList contains all elements from map's lists.

long count = collect.values()
            .stream()
            .filter(list -> list.containsAll(myList))
            .count();

Answer 4

I think you're using wrong collection to store your data. Based on what you wrote, you want a map with integer keys and two-element tuples as values and then use Multiset to count frequencies:

Multiset is a collection that supports order-independent equality, like Set , but may have duplicate elements. A multiset is also sometimes called a bag .

Elements of a multiset that are equal to one another are referred to as occurrences of the same single element. The total number of occurrences of an element in a multiset is called the count of that element (the terms "frequency" and "multiplicity" are equivalent , but not used in this API).

The code below assumes you have proper implementation of two-element tuple (aka pair, or your Storage class, but with proper equals and hashCode implementations), like this one from jOOL :

HashMap<Integer, Tuple2<String, String>> m = new HashMap<>();
Tuple2<String, String> carTuple = new Tuple2<>("key", "car");
Tuple2<String, String> blueTuple = new Tuple2<>("key", "blue");

m.put(1, carTuple);
m.put(2, blueTuple);
m.put(3, carTuple);

ImmutableMultiset<Tuple2<String, String>> occurrences = 
    ImmutableMultiset.copyOf(m.values());
System.out.println(occurrences); // [(key, car) x 2, (key, blue)]

If you need to have few values (tuples) mapped under one key (integer), then you should change the first line to multimap:

ListMultimap<Integer, Tuple2<String, String>> m = ArrayListMultimap.create();

so that m.put(1, anotherTuple) is possible and putting doesn't override first value ( carTuple ) but rather adds it under 1 values list.

EDIT:

You can implement Tuple2 yourself if you don't need/want additional dependency, it could look like this class:

public class Tuple2<T1, T2> {

  public final T1 v1;
  public final T2 v2;

  public Tuple2(T1 v1, T2 v2) {
    this.v1 = v1;
    this.v2 = v2;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (!(o instanceof Tuple2)) {
      return false;
    }
    @SuppressWarnings({"unchecked", "rawtypes"}) final Tuple2<T1, T2> that = (Tuple2) o;
    return Objects.equals(v1, that.v1) && Objects.equals(v2, that.v2);
  }

  @Override
  public int hashCode() {
    return Objects.hash(v1, v2);
  }

  @Override
  public String toString() {
    return "(" + v1 + ", " + v2 + ")";
  }
}