Un'espressione lambda crea un oggetto sull'heap ogni volta che viene eseguita?

Quando eseguo l'iterazione su una raccolta utilizzando il nuovo zucchero sintattico di Java 8, ad esempio

myStream.forEach(item -> {
  // do something useful
});

Questo non equivale al frammento di "vecchia sintassi" qui sotto?

myStream.forEach(new Consumer<Item>() {
  @Override
  public void accept(Item item) {
    // do something useful
  }
});

Questo significa che un nuovo Consumeroggetto anonimo viene creato sull'heap ogni volta che eseguo l'iterazione su una raccolta? Quanto spazio heap richiede? Quali sono le implicazioni sulle prestazioni? Significa che dovrei piuttosto usare il vecchio stile per i loop quando si scorre su grandi strutture dati multi-livello?

È equivalente ma non identico. Detto semplicemente, se un'espressione lambda non acquisisce valori, sarà un singleton che verrà riutilizzato in ogni invocazione.

Il comportamento non è esattamente specificato. Alla JVM viene data grande libertà su come implementarla. Attualmente, la JVM di Oracle crea (almeno) un'istanza per espressione lambda (ovvero non condivide un'istanza tra espressioni identiche diverse) ma crea singleton per tutte le espressioni che non acquisiscono valori.

Puoi leggere questa risposta per maggiori dettagli. Lì, non solo ho dato una descrizione più dettagliata, ma ho anche testato il codice per osservare il comportamento attuale.

Questo è coperto da The Java® Language Specification, capitolo “ 15.27.4. Valutazione run-time delle espressioni lambda ”

riassunte:

Queste regole hanno lo scopo di offrire flessibilità alle implementazioni del linguaggio di programmazione Java, in quanto:

• Non è necessario assegnare un nuovo oggetto ad ogni valutazione.

• Gli oggetti prodotti da diverse espressioni lambda non devono appartenere a classi diverse (se i corpi sono identici, ad esempio).

• Ogni oggetto prodotto dalla valutazione non deve necessariamente appartenere alla stessa classe (le variabili locali acquisite potrebbero essere incorporate, ad esempio).

• Se è disponibile una "istanza esistente", non è necessario che sia stata creata in una precedente valutazione lambda (potrebbe essere stata allocata durante l'inizializzazione della classe che la racchiude, ad esempio).

Quando un'istanza che rappresenta la lambda viene creata in modo sensibile dipende dal contenuto esatto del corpo della tua lambda. Vale a dire, il fattore chiave è ciò che la lambda cattura dall'ambiente lessicale. Se non acquisisce alcuno stato variabile da una creazione all'altra, non verrà creata un'istanza ogni volta che viene inserito il ciclo for-each. Invece verrà generato un metodo sintetico in fase di compilazione e il sito di utilizzo lambda riceverà semplicemente un oggetto singleton che delega a quel metodo.

Si noti inoltre che questo aspetto dipende dall'implementazione e ci si può aspettare raffinamenti e progressi futuri su HotSpot verso una maggiore efficienza. Esistono piani generali per esempio per realizzare un oggetto leggero senza una classe corrispondente completa, che abbia le informazioni sufficienti per inoltrare a un singolo metodo.

Ecco un buon articolo di approfondimento accessibile sull'argomento:

http://www.infoq.com/articles/Java-8-Lambdas-A-Peek-Under-the-Hood

Stai passando una nuova istanza al forEachmetodo. Ogni volta che lo fai crei un nuovo oggetto ma non uno per ogni iterazione di loop. L'iterazione viene eseguita all'internoforEach metodo utilizzando la stessa istanza dell'oggetto 'callback' fino a quando non viene eseguita con il ciclo.

Quindi la memoria utilizzata dal loop non dipende dalla dimensione della raccolta.

Questo non equivale allo snippet "vecchia sintassi"?

Sì. Ha lievi differenze a un livello molto basso ma non credo che dovresti preoccupartene. Le espressioni di Lamba usano la funzione invokedynamic anziché le classi anonime.