'forEach(java.util.function.Consumer)' in 'java.lang.Iterable' cannot be applied

[Monica Shiralkar]

I ran a simple lambda example which ran fine. After that I am trying to run it without lambda (using anonymous class). However, it is giving error "'forEach(java.util.function.Consumer)' in 'java.lang.Iterable' cannot be applied to '(anonymous MyInterface)'".

import java.util.ArrayList;
import java.util.List;

public class AnnonomousExample {

    public static void main(String[] args) {
        List myList = new ArrayList();
        myList.add("1");
        myList.add("2");
        myList.add("3");

        System.out.println("Using Lambda");
        myList.forEach(a-> System.out.println(a));

        System.out.println("Using Anonymous class");
        myList.forEach(new MyInterface() {
            public void display(String a) {

           System.out.println(a);
        }
        });
    }
}

Below is the MyInterface  interface.

public interface MyInterface {
    void display(String a);
}

How can I resolve this? Thanks.

[Carey Brown]

import java.util.ArrayList;
import java.util.List;
 
public class AnnonomousExample {
 
    public static void main(String[] args) {
        List<String> myList = new ArrayList<>();
        myList.add("1");
        myList.add("2");
        myList.add("3");
 
        System.out.println("Using Lambda");
        myList.forEach(a-> System.out.println(a));
 
        System.out.println("Using Anonymous class");
        myList.forEach( a->new MyInterface() {
            public void display(String a) {
 
           System.out.println(a);
        }
        });
    }
}

interface MyInterface {
    void display(String a);
}

[Piet Souris]

There are a few problems with your code.

First of all, lets simplify the code a little. In your main method, start with

var myI = new MyInterface() {
    @Override
    public void display(String s) {
        System.out.println(s);
    }
};

and then you must do:

myList.forEach(s -> myI.display(s));

Second problem is that your List is a List of Objects, and so you get an error, because your interface expects a String to be printed, but instead it gets an Object. In Carey's snippet you see that he uses a List<String>, to remedy this problem.

Third problem is that you define a String as parameter in the display-method of your interface. So if you have a List of, say, Integers, the above will not work. So you could have your interface to be

interface MyInterface {
    void display(Object s);
}

and then do

var myI = new MyInterface() {
    @Override
    public void display(Object s) {
        System.out.println(s);
    }
};

and do:

var list = List.of(1, 2, 3);
list.forEach(i -> myI.display(i));

or with a method reference:

list.forEach(myI::display);

[Stephan van Hulst]

I think you guys are missing Monica's point. The goal is to NOT use a lambda expression, but instead replace it completely with an instance of an anonymous class.

Monica, forEach() requires a Consumer. You can't pass it a MyInterface, because MyInterface isn't a Consumer. To pass the forEach() method an instance of an anonymous class, you have to do this:

myList.forEach(new Consumer<>() {
  @Override
  public void accept(String string) {
    System.out.println(string);
  }
});

Note that this requires that you've properly parameterized myList, which you currently haven't.

[Piet Souris]

Fair enough, but I was concentrating on the 'MyInterface'. So the full story would then become

myList.forEach(new Consumer() {
    public void accept(Object e) {
        new MyInterface() {
            public void display(Object e) {
                System.out.println(e);
            }
                          }.display(e);
        }
    }
);

[Tim Holloway]

Aside from possibly intellectual curiosity (this is Monica, after all ), I'm not sure about the advantage of using a forEach() method over simply using the general language foreach verb which works on arrays and Iterables. Or a stream, for that matter.

[Stephan van Hulst]

The only advantage I see for using forEach() on collections is that it might be more succinct when passing in a method reference or short lambda expression:

elements.forEach(System.out::println);

In general though, I too prefer the enhanced for-loop, which clearly advertises its non-functional nature. To me, a functional coding style involves pure functions, and forEach() is impure.

There is a clear advantage to using forEach() on streams though. It makes it really easy to perform parallel tasks:

tasks.stream().parallel().forEach(Worker::process);

[Monica Shiralkar]

Stephan van Hulst wrote: To pass the forEach() method an instance of an anonymous class, you have to do this:

myList.forEach(new Consumer<>() {
  @Override
  public void accept(String string) {
    System.out.println(string);
  }
});

,

Thanks.
The accept method of consumer takes the type Object, and not a String. So I took that and did a toString to it . It worked fine.

Here I had to convert object to String using toString method then why is is so that in the lambda code above it was not required to convert to string from object ?

Stephan van Hulst wrote:. You can't pass it a MyInterface,

Ok. So in which case can we pass our own interface to a higher order method ?

[Mike Simmons]

Monica Shiralkar wrote:Here I had to convert object to String using toString method then why is is so that in the lambda code above it was not required to convert to string from object ?

Stephan previously commented (on the very code you're asking about):

Stephan van Hulst wrote:Note that this requires that you've properly parameterized myList, which you currently haven't.

To spell this out more clearly: you defined myList like this:

        List myList = new ArrayList();

Here, you are not using generics at all.  You presumably got a warning like "raw use of parameterized class ArrayList", which you ignored.  This is generally a bad practice - you should provide parameters for classes like this.   In this case, it seems like all the things you're putting in the list are Strings, so it seems sensible to say it's an ArrayList of Strings:

        List<String> myList = new ArrayList<>();

Now you will find that in subsequent code, you don't need to do things like convert an Object to a String, because the compiler already knows you have a list of Strings.  That's what Stephan means by properly parameterizing myList.

You can also declare it as a List<Object> if you want:

        List<Object> myList = new ArrayList<>();

In that case you might later have to call toString() if you need a String from it.  But at least in that case, you've made a conscious choice to treat myList as a List of Objects.

Monica Shiralkar wrote:Ok. So in which case can we pass our own interface to a higher order method ?

You can pass an instance of your own MyInterface to any method that accepts a MyInterface, or to any method that accepts a supertype of MyInterface.  From your definition of MyInterface, it doesn't implement or extend anything else... so the only other valid supertype would be Object.  In this thread, the method you were trying to use was forEach() which takes a type of Consumer.  Since MyInterface doesn't implement Consumer, you can't use the method.  If you make MyInterface implement Consumer, you can.

Now the confusing thing here is that if you were using a lambda expression here, not an interface, then the rules for that are much looser, and the compiler will let you write something like

        myList.forEach(a-> System.out.println(a));

where it will figure out that since forEach takes a Consumer, and Consumer only has one method, then your "a -> System.out.println(a)" must be intended to be an implementation of that method - so it will convert the lambda expression to act like an instance of Consumer for this method call, without you having to explain that to the compiler somehow.  

Why do we get this flexibility for a lambda, but not for an anonymous class implementing an interface?  Well, mostly because lambdas came to Java later on, long after interfaces.  In the beginning Java was designed to be pickier and to force you to make sure you were using the right type for everything... often in the most verbost way possible.  Nowadays, they are more likely to design a feature to be a little more flexible, and not require you to declare things that it can infer on its own.  If they were designing the language from scratch, it might well be done differently.  But instead, we just have to accept that the rules evolved they way the rules evolved.

[Rob Spoor]

Piet Souris wrote:Fair enough, but I was concentrating on the 'MyInterface'. So the full story would then become

myList.forEach(new Consumer() {
    public void accept(Object e) {
        new MyInterface() {
            public void display(Object e) {
                System.out.println(e);
            }
                          }.display(e);
        }
    }
);

That can be done a bit simpler using a method reference:

myList.forEach(new MyInterface() {
    public void display(String a) {
        System.out.println(a);
    }
}::display);

You don't even need an existing interface for that:

myList.forEach(new Object() {
    public void display(String a) {
        System.out.println(a);
    }
}::display);

(Of course all of this is a lot more complex than just myList.forEach(a -> System.out.println(a)) or myList.forEach(System.out::println))

[Fikri Harlov]

Another solution, using default method display():

import java.util.List;
import java.util.function.Consumer;

public class Main
{
    public static void main(String[] args)
    {
        List<Object> objectList = List.of(1, "2", "Hello", "Java", "World");

        //The "Object" type is inferred from the type of the list items.
        objectList.forEach
        (   new MyInterface<>()
            {   @Override
                public void accept(Object object) { display(object); }
            }
        );
    }

    interface MyInterface<T> extends Consumer<T>
    {
        default void display(T x) { System.out.println(x); }
    }
}

[Campbell Ritchie]

Apart from the bad indentation: that trick would work. It does seem overkill, however, to extend that interface to add a method. What would happen if you added that method to the anonymous class?

[Fikri Harlov]

Campbell Ritchie wrote:It does seem overkill, however, to extend that interface to add a method. What would happen if you added that method to the anonymous class?

She wants to pass MyInterface to a forEach(), but it is not a Consumer.

If method display() contains 20 lines source code, it will be ugly to be in the forEach()

In MyInterface we can put many more default methods that will be more beautiful to be outside the forEach().

[Campbell Ritchie]

Fikri Harlov wrote:. . . If method display() contains 20 lines source code, it will be ugly to be in the forEach() . . .

There is a lot more to it than that. Have you tried it yourself?

[Fikri Harlov]

If the display() method is in the anonymous class, I can't reuse it anywhere else in the program.

[Campbell Ritchie]

You can't reuse it anywhere from that interface anyway; it would only compile with private access when I tried it.

[edit]Sorry, I said interface when I should have said anonymous class.

[Campbell Ritchie]

Nobody ever liked anonymous classes anyway, and nobody shed any tears when many of them were replaced by λs.

[Fikri Harlov]

Reusing display() method.

import java.util.List;
import java.util.function.Consumer;

public class Main
{
    public static void main(String[] args)
    {
        List<Object> objectList = List.of(1, "2", "Hello", "Java", "World");

        //The "Object" type is inferred from the type of the list items.
        objectList.forEach
        (   new MyInterface<>()
            {   @Override
                public void accept(Object object) { display(object); }
            }
        );

        List<Double> numbers = List.of(3.14, 2.71, 5.21);
        //Reusing display() method.
        numbers.forEach
        (   new MyInterface<>()
            {   @Override
                public void accept(Double x) { display(x); }
            }
        );
    }

    interface MyInterface<T> extends Consumer<T>
    {
        default void display(T x) { System.out.println(x); }
    }
}

[Fikri Harlov]

Campbell Ritchie wrote:Nobody ever liked anonymous classes anyway, . . .

In forEach() I use an anonymous class that implements MyInterface. Anonymous classes are a very good thing.

[Mike Simmons]

Well, if you like anonymous classes, then you like them.  And "no one ever liked them" is an overstatement.  But... when was the last time you used an anonymous class for something that couldn't be done more easily with a lambda?  I'm sure that such situations exists.  But how often does it come up, really?

[Fikri Harlov]

Whenever I need a class with fields rather than a simple function like a lambda.

[Carey Brown]

touché

[Campbell Ritchie]

Mike Simmons wrote:. . . an overstatement.

To quote Carey,



touché!

But... when was the last time you used an anonymous class for something that couldn't be done more easily with a lambda? . . .

When I wanted to show how you can convert an anonymous class to a λ or a method reference!

[Carey Brown]

Although... I was trying to find an example in my source code archive and only came up with examples like this. This was NOT implemented as an ANONYMOUS class because the constructor takes a parameter so it could be used in more than one place.

		private class DirectionAction
		extends AbstractAction
		{
			Direction			direction;
			
			public DirectionAction( Direction direction )
			{
				this.direction = direction;
			}
			
			public void actionPerformed( ActionEvent evt )
			{
				if( directionPending == null )
					directionPending = direction;
			}
		}

[Carey Brown]

Fikri Harlov wrote:Whenever I need a class with fields rather than a simple function like a lambda.

@Fikri, I think you may have a valid point but I'm having a hard time coming up with a legitimate example. Could you please provide one?

[Carey Brown]

This might be an example of an anonymous class with a field, though it also has a lambda feature.

import java.util.List;
import java.util.function.Consumer;

public class AnonymousClass
{
	static List<String>	ones = List.of( "one", "two", "three", "four" );
	static List<String>	tens = List.of( "ten", "twenty", "thirty", "forty" );
	
	public static void main( String[] args )
	{
		ones.forEach( new Consumer<Object>()
		{
			int num = 0;
			public void accept( Object s )
			{
				System.out.println( ++num + "  " + s );
			}
		}::accept );
		
		tens.forEach( new Consumer<Object>()
		{
			int num = 0;
			public void accept( Object s )
			{
				System.out.println( ++num + "  " + s );
			}
		}::accept );
	}
}

[Fikri Harlov]

I refactor your code, eliminating unnecessary things.

import java.util.List;
import java.util.function.Consumer;

public class Main
{
    static List<String> ones = List.of( "one", "two", "three", "four" );
    static List<String> tens = List.of( "ten", "twenty", "thirty", "forty" );

    public static void main(String[] args)
    {
        ones.forEach(new Consumer<>()
        {   int num = 0;

            public void accept(String s)
            {   System.out.println(++num + "  " + s);
            }
        });

        tens.forEach(new Consumer<>()
        {   int num = 0;

            public void accept(String s)
            {   System.out.println(++num + "  " + s);
            }
        });
    }
}

Output:
1  one
2  two
3  three
4  four
1  ten
2  twenty
3  thirty
4  forty

[Fikri Harlov]

I use an anonymous class in the generate() method, not Lambda.

import java.util.Arrays;
import java.util.stream.LongStream;
import java.util.function.LongSupplier;

public class FibonacciNumbersStream
{
    public static void main(String[] args)
    {
        System.out.println(Arrays.toString(getFibNums(1).toArray()));
        System.out.println(Arrays.toString(getFibNums(2).toArray()));
        System.out.println(Arrays.toString(getFibNums(7).toArray()));
        System.out.println(getFibNums(10).boxed().toList());
        System.out.println(getFibNums(17).boxed().toList());
        System.out.println(getFibNums(20).boxed().toList());
    }

    private static LongStream getFibNums(long count)
    {   return LongStream.generate
        (   new LongSupplier()
            {   long a, b = 1, oldA;

                public long getAsLong()
                {   oldA = a;
                    a = (b += a) - a;
                    return oldA;
                }
            }
        ).limit(count);
    }
}

Output:
[0]
[0, 1]
[0, 1, 1, 2, 3, 5, 8]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]