Java8流并行减少BiFunction累加器

Question

i have a learning java 8 the most difficult thing i have to face is the Parallel reduction. here is the code from a example of the user @Stuart Marks i am studying with.

class ImmutableAverager 
{
    private final int total;
    private final int count;
    public ImmutableAverager(){this.total = 0;this.count = 0;}
   public ImmutableAverager(int total, int count)
   {
      this.total = total;
      this.count = count;
   }
   public double average(){return count > 0 ? ((double) total) / count : 0;}
   public ImmutableAverager accept(final int i)
   {
       return new ImmutableAverager(total + i, count + 1);
   }
   public ImmutableAverager combine(final ImmutableAverager other)
   {
       return new ImmutableAverager(total + other.total, count + other.count);
   }  

the call

public static void main(String[] args)     
{
       System.out.println(Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        .parallel()
        .reduce(new ImmutableAverager(), 
                ImmutableAverager::accept,
                ImmutableAverager::combine)
        .average());    
}

this produce the right results but later i checked the signature of the reduce method

<U> U reduce(U identity,
             BiFunction<U, ? super T, U> accumulator,
             BinaryOperator<U> combiner);

i would understand clear if the code would be something like

.reduce(new ImmutableAverager(),(a,b)->a.accept(b),(a,b)->a.combine(b))

i dont understand how

 ImmutableAverager::accept

can convert into a BiFunction

my understanding is..

this

ImmutableAverager::accept

is convert it in something like

(ImmutableAverage a)->a.accept();//but this is a function with 1 parameter not with 2 parameters.

and

ImmutableAverager::merge

can convert into a BinaryOperator my friend @Stuart Marks says

the methods match the function arguments to reduce so we can use method references.

sorry if the question is simple but any help is hugely appreciate..

best regards from Venezuela

Answer 1

Yes, there's a subtlety here regarding the way that arguments are shifted when this kind of method reference is used, specifically an "unbound" method reference.

Let's look at the second argument of reduce() . It wants

BiFunction<U, ? super T, U> accumulator

and so the signature of its abstract method is:

U apply(U, T)

(wildcard elided for brevity). The example had used a method reference ImmutableAverager::accept and its signature is:

ImmutableAverager accept(int i)

It looks like this doesn't work, because a BiFunction requires two arguments, whereas the accept method takes only one. But notice that the accept method is an instance method on the ImmutableAverager class, so it implicitly also takes a "receiver", that is, the object upon which this method is called. An ordinary call to this method might look like this:

newAverager = oldAverager.accept(i);

So really, the accept method actually takes two arguments even though it doesn't look like it. The first is the receiver, which is of type ImmutableAverager , and the second is of type int . The method call syntax makes it look like there's something special about the receiver, but there really isn't. It's as if this were a static method called like this:

newAverager = accept(oldAverager, i);

Now let's look at how this works with the reduce call. The code in question is,

reduce(..., ImmutableAverager::accept, ...)

I'm only showing the second argument here. This needs to be a BiFunction that takes arguments of U and T and returns a U as shown above. If you look at the accept method and treat the receiver not as something special but as an ordinary argument, it takes an argument of type ImmutableAverager and an argument of type int , and returns an ImmutableAverager . So U is inferred to be ImmutableAverager and T is inferred to be Integer (boxed from int ), and the method reference here works.

The key point is, for an unbound method reference, the method reference is to an instance method but the method is specified using the class name instead of an actual instance. When this occurs, the receiver turns into the first argument of the method call.