@Override
    public Map.Entry<K, V> reduce(Map.Entry<K, V> identity, BinaryOperator<Map.Entry<K, V>> accumulator) {
        return inner.reduce(requireNonNull(identity), requireNonNull(accumulator));
    }
Performs a reduction on the elements of this stream, using the provided 
identity value and an associative accumulation function, and returns the 
reduced value. This is equivalent to:
<pre>{@code
    T result = identity;
    for (T element : this stream)
        result = accumulator.apply(result, element)
    return result;
}</pre>

but is not constrained to execute sequentially.
<p>
The {@code identity} value must be an identity for the accumulator
function. This means that for all {@code t},
{@code accumulator.apply(identity, t)} is equal to {@code t}.
The {@code accumulator} function must be an associative function.
<p>
This is a terminal operation.

<p> Sum, min, max, average, and string concatenation are all special
cases of reduction. Summing a stream of numbers can be expressed as:

<pre>{@code
    Integer sum = integers.reduce(0, (a, b) -> a+b);
}</pre>

or:

<pre>{@code
    Integer sum = integers.reduce(0, Integer::sum);
}</pre>
<p>
While this may seem a more roundabout way to perform an aggregation
compared to simply mutating a running total in a loop, reduction
operations parallelize more gracefully, without needing additional
synchronization and with greatly reduced risk of data races.

@param identity     the identity value for the accumulating function
@param accumulator  an associative, non-interfering stateless function 
                    for combining two values
@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