番石榴：如何定制减少多图？

Question

Is the concept of reduce implemented in Guava libs? I mean I have a multimap:

[1] -> 1, 2, 5, 8
[2] -> 3, 6, 4
[3] -> 1, 0

Then I have a multiplying function :

(a, b) -> a * b

And I want to get the following map:

[1] -> 80          // 1 * 2 * 5 * 8
[2] -> 72          // 3 * 6 * 4
[3] -> 0           // 1 * 0

How do I do it in Guava?

Answer 1

I don't think there is a reduction operation in Guava. I guess you have two options.

If you're using java-8 , just stream over the entry set, and collect the entries into a new map with groupingBy and reduce .

import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.mapping;
import static java.util.stream.Collectors.reducing;

...

Map<Integer, Integer> map = 
    multimap.entries()
            .stream()
            .collect(groupingBy(Map.Entry::getKey,
                                reducing(1, Map.Entry::getValue, (a, b) -> a * b)));

groupingBy as you can guess, will group the entries by their key values. Then we just reduce the values grouped (which are Entry<Integer, Integer> ) by first mapping their to their values and finally by multiplying them - providing the identity value which is 1 for the multiplication.

---

If you can't use java-8 , you can get back a Map<Integer, Collection<Integer>> from your Multimap with Multimaps.asMap and use Maps.transformValues :

 Map<Integer, Collection<Integer>> tempMap = Multimaps.asMap(oldMap); Map<Integer, Integer> newMap = Maps.transformValues(tempMap, new Function<Collection<Integer>, Integer>() { @Nullable @Override public Integer apply(Collection<Integer> input) { //do the multiplication here return 0; } }); 

Answer 2

Used String key and List<Integer> as values.

You can also try something like

    Map<String, List<Integer>> test = new HashMap<String, List<Integer>>();
    test.put("a", Lists.newArrayList(1, 2, 3));
    test.put("b", Lists.newArrayList(4, 5, 6));

    Map<String, Integer> transformEntries = Maps.transformEntries(test, new EntryTransformer<String, List<Integer>, Integer>() {

        @Override
        public Integer transformEntry(String key, List<Integer> values) {
            Integer a = 1;
            for (Integer value : values) {
                a = value * a;
            }
            return a;
        }
    });

    System.out.println(transformEntries);

Result : {a=6, b=120}

Maps.EntryTransformer

Answer 3

The easiest way looks like using a stream over entries() , and mapping a function over it that converts the collection to a stream and runs a suitable reduce() function over that.

Something like this:

HashMap<Integer, Integer> collected =
    mmap.entries().stream().collect(HashMap::new,
            (map, e) -> {
                map.put(e.getKey(), e.getValue().stream().reduce((a, b) -> (a * b)).get());
            }, HashMap::putAll);