Differenze di implementazione/ottimizzazioni tra espressioni Lambda e classi anonime

Question

Supponiamo che voglia eseguire un'iterazione su una raccolta di oggetti.

List<String> strmap = ... 
//Without lambdas 
strmap.stream().filter(new Predicate<String>() { 
     public boolean test(String string) { 
      return string.length == 10; 
     } 
}.forEach(new Consumer<String>() { 
     public void accept (String string) { 
      System.out.println("string " + string + " contains exactly 10 characters"); 
     } 
} 
//With lambdas 
strmap.stream() 
     .filter(s -> s.length == 10) 
     .forEach(s -> System.out.println("string " + s + " contains exactly 10 characters"); 

Come funziona il secondo esempio (senza lambda)? Un nuovo oggetto (Predicate e Consumer) creato ogni volta che chiamo il codice, quanto può il compilatore java jit ottimizzare l'espressione lambda? Per una performance migliore dovrei dichiarare tutti i lambda come una variabile e sempre solo passare un riferimento?

private Predicate<String> length10 = s -> s.length == 10; 
private Consumer<String> printer = s -> { "string " + s + " contains exactly 10 characters"; } 

strmap.stream() 
     .filter(length10) 
     .forEach(printer); 

Answer 1

Come funziona il secondo esempio (senza lambda) funziona? Un nuovo oggetto (Predicate e Consumer) creato ogni volta che chiamo il codice, quanto può il compilatore java jit ottimizzare l'espressione lambda? Per una performance migliore dovrei dichiarare tutti i lambda come una variabile e sempre solo passare un riferimento?

Il lavoro del JIT è di farlo in modo da non doversi preoccupare di nulla di tutto questo. Ad esempio, il JIT può (e, credo, lo farà) fare in modo che s -> s.length == 10 diventi automaticamente una costante statica, quindi viene riutilizzata in tutta la classe, non solo in quell'istanza. Potrebbe anche essere riutilizzato in altre classi che usano lo stesso lambda da qualche altra parte.

L'intero punto di lambda è che si dovrebbe semplicemente scrivere il codice più semplice che abbia senso e il JIT ha la libertà di fare tutto il necessario per renderlo efficiente. Ad esempio, ecco perché i lambda vengono generati usando invokedynamic invece di essere semplicemente desugared alle classi interne anonime in primo luogo.

Scrivere il codice semplice; confida che il JIT faccia la cosa giusta. Ecco a cosa serve. Detto questo, se vuoi i dettagli opprimenti e complicati, il numero this è quasi certamente la fonte migliore.