@Override
    public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super Map.Entry<K, V>> accumulator, BiConsumer<R, R> combiner) {
        return inner.collect(requireNonNull(supplier), requireNonNull(accumulator), requireNonNull(combiner));
    }
Performs a mutable reduction operation on the elements of this stream. A 
mutable reduction is one in which the reduced value is a mutable result 
container, such as an {@code ArrayList}, and elements are incorporated by 
updating the state of the result rather than by replacing the result. 
This produces a result equivalent to:
<pre>{@code
    R result = supplier.get();
    for (T element : this stream)
        accumulator.accept(result, element);
    return result;
}</pre>
<p>
Like {@link #reduce(BinaryOperator)} , {@code collect} operations
can be parallelized without requiring additional synchronization.
<p>
This is a terminal operation.

<p> There are many existing classes in the JDK whose signatures are
well-suited for use with method references as arguments to {@code collect()}.
For example, the following will accumulate strings into an {@code ArrayList}:
<pre>{@code
    List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add,
                                               ArrayList::addAll);
}</pre>
<p>
The following will take a stream of strings and concatenates them into a
single string:
<pre>{@code
    String concat = stringStream.collect(StringBuilder::new, StringBuilder::append,
                                         StringBuilder::append)
                                .toString();
}</pre>

@param <R>          type of the result
@param supplier     a function that creates a new result container. For a
                    parallel execution, this function may be called
                    multiple times and must return a fresh value each 
                    time.
@param accumulator  an associative, non-interfering, stateless function 
                    for incorporating an additional element into a result
@param combiner     an associative, non-interfering, stateless function 
                    for combining two values, which must be compatible 
                    with the accumulator function
@return             the result of the reduction
@throws NullPointerException if any of the provided parameters are {@code null}
common-parent/mapstream/src/main/java/com/speedment/common/mapstream/MapStream.java