Performance difference between Java 8 lambdas and anonymous inner classes

Before Java 8, lambda functionality could be achieved by using anonymous inner classes. For example:

interface Lambda {
    void doStuff();
}

// ...

public void doWithCallback(Lambda callback) {
    // ...
    callback.doStuff();
}

// ...

doWithCallback(new Lambda { 
    public void doStuff() { 
        // ... 
    } 
});

In terms of performance, is there a difference between still using this approach and using the new Java 8 lambdas?

Oracle has posted a study comparing performance between Lambdas and anonymous classes

See JDK 8: Lambda Performance Study by Sergey Kuksenko, which is 74 slides long.

Summary: slow to warm up but when JIT inlines it worst case just as fast as anonymous class but can be faster.

As I found, the iterating over array with Stream is working much slower (74 slides are not consider such the case). I think that it is not the only performance leaks in lambdas (guess, it will be improved in the future). The example below was running with Java 8 without any options:

	//Language is an enum 
	Language[] array = Language.values();
	System.err.println(array.length); // 72 items
	long t = System.nanoTime();
	for (Language l : array) System.out.println(l.getLanguageName());
	System.err.println(System.nanoTime()-t); //nano time  1864724

	t = System.nanoTime();
	Arrays.stream(array).forEach(v -> System.out.println(v.getLanguageName()));
	System.err.println(System.nanoTime()-t); //nano time 55812625 (55812625/1864724 = 29.93 times longer)

	List<Language> list = Arrays.asList(array);

	t = System.nanoTime();
	for (Language l : list) System.out.println(l.getLanguageName());
	System.err.println(System.nanoTime()-t); //nano time 1435008

	t = System.nanoTime();
	list.forEach(v -> System.out.println(v.getLanguageName()));
	System.err.println(System.nanoTime()-t); //nano time 1619973 (1619973/1435008 = 1.128 times longer)