Limitations of forEach with instance method references in Java 8

Question

Assume I have the following functional interface:

public interface TemperatureObserver {
    void react(BigDecimal t);
}

and then in another class an already filled-in ArrayList of objects of type TemperatureObserver. Assuming that temp is a BigDecimal, I can invoke react in a loop using:

observers.forEach(item -> item.react(temp));

My question: can I use a method reference for the code above?

The following does not work:

observers.forEach(TemperatureObserver::react);

The error message is telling me that

1. forEach in the Arraylist observers is not applicable to the type TemperatureObserver::react
2. TemperatureObserver does not define a method react(TemperatureObserver)

Fair enough, as forEach expects as an argument a Consumer<? super TemperatureObserver>, and my interface, although functional, does not comply to Consumer because of the different argument of react (a BigDecimal in my case).

So can this be solved, or it is a case in which a lambda does not have a corresponding method reference?

Answer 1

There are three kinds of method references that can be used when a single value is available from the stream:

1. A parameter-less method of the streamed object.

   class Observer {
       public void act() {
           // code here
       }
   }
   
   observers.forEach(Observer::act);
   
   observers.forEach(obs -> obs.act()); // equivalent lambda
   

   The streamed object becomes the this object of the method.

2. A static method with the streamed object as parameter.

   class Other {
       public static void act(Observer o) {
           // code here
       }
   }
   
   observers.forEach(Other::act);
   
   observers.forEach(obs -> Other.act(obs)); // equivalent lambda
   

3. A non-static method with the streamed object as parameter.

   class Other {
       void act(Observer o);
   }
   
   Other other = new Other();
   observers.forEach(other::act);
   
   observers.forEach(obs -> other.act(obs)); // equivalent lambda
   

There is also a constructor reference, but that is not really relevant to this question.

Since you have an external value temp, and you want to use a method reference, you can do the third option:

class Temp {
    private final BigDecimal temp;
    public Temp(BigDecimal temp) {
        this.temp = temp;
    }
    public void apply(TemperatureObserver observer) {
        observer.react(this.temp);
    }
}

Temp tempObj = new Temp(temp);

observers.forEach(tempObj::apply);

Answer 2

Take a look at the Method References section in the Java Tutorial. There it says:

There are four kinds of method references:

• Reference to a static method: ContainingClass::staticMethodName

• Reference to an instance method of a particular object: containingObject::instanceMethodName

• Reference to an instance method of an arbitrary object of a particular type: ContainingType::methodName

• Reference to a constructor: ClassName::new

There it explains that i.e. TemperatureObserver::react would be a method reference of the 3rd type: a reference to an instance method of an arbitrary object of a particular type. In the context of your call to the Stream.forEach method, that method reference would be equivalent to the following lambda expression:

(TemperatureObserver item) -> item.react()

Or just:

item -> item.react()

Which doesn't match your void TemperatureObserver.react(BigDecimal t) method signature.

As you already suspect, there are cases for which you can't find an equivalent method reference for a lambda. Lambdas are way more flexible, though IMHO sometimes they are less readable than method references (but this is a matter of taste, many people think the other way round).

A way to still use a method reference would be with a helper method:

public static <T, U> Consumer<? super T> consumingParam(
        BiConsumer<? super T, ? super U> biConsumer,
        U param) {

    return t -> biConsumer.accept(t, param);
}

Which you could use as follows:

observers.forEach(consumingParam(TemperatureObserver::react, temp));

But, honestly, I prefer to use a lambda.

Answer 3

It does not works, because you iterate over handlers, not over parameters.

For example, this code works:

    ArrayList<BigDecimal> temps = new ArrayList<>();

    TemperatureObserver observer = new TemperatureObserverImpl();

    temps.forEach(observer::react);