Un'espressione lambda è qualcosa di più di una classe interna anonima con un solo metodo?

C'è un nuovo clamore con le tanto attese espressioni lambda in Java 8; ogni 3 giorni viene pubblicato un altro articolo con loro su quanto sono belli.

Per quanto ho capito, un'espressione lambda non è altro che una classe interna anonima con un solo metodo (almeno a livello di codice byte). Oltre a questo viene fornito con un'altra bella inferenza tipo-funzione, ma credo che l'equivalente di questo possa essere raggiunto con i generici su un certo livello (ovviamente non in modo così pulito come con le espressioni lambda).

Sapendo questo, le espressioni lambda porteranno qualcosa di più di una zuccherina sintattica in Java? Posso creare classi più potenti e flessibili o altri costrutti orientati agli oggetti con espressioni lambda che non è possibile creare con le funzionalità del linguaggio corrente?

tl; dr: mentre è principalmente zucchero sintattico, quella sintassi più piacevole rende molte cose pratiche che finivano in infinite e illeggibili linee di parentesi graffe e parentesi.

Bene, in realtà è il contrario perché le lambda sono molto più vecchie di Java. Le classi interne anonime con un solo metodo sono (erano) il Java più vicino ad Lambdas. È un'approssimazione che è stata "abbastanza buona" per qualche tempo, ma ha una sintassi molto brutta.

In apparenza, i lambda Java 8 sembrano non essere molto più dello zucchero sintattico, ma quando guardi sotto la superficie, vedi tonnellate di astrazioni interessanti. Ad esempio, le specifiche JVM trattano un lambda in modo molto diverso da un oggetto "vero" e mentre è possibile gestirli come se fossero oggetti in cui, non è necessario che JVM li implementi come tali.

Ma mentre tutto quel trucco tecnico è interessante e pertinente (poiché consente future ottimizzazioni nella JVM!), Il vero vantaggio è "solo" la parte sintattica dello zucchero.

Cosa c'è di più facile da leggere:

myCollection.map(new Mapper<String,String>() {
  public String map(String input) {
    return new StringBuilder(input).reverse().toString();
  }
});

o:

myCollection.map(element -> new StringBuilder(element).reverse().toString());

oppure (usando un handle di metodo anziché un lambda):

myCollection.map(String::toUpperCase);

Il fatto che tu possa finalmente esprimere in modo conciso che in precedenza sarebbero 5 righe di codice (di cui 3 sono assolutamente noiose) porta un vero cambiamento di ciò che è pratico (ma non di ciò che è possibile, concesso).

Per Java, sì, non è altro che un modo migliore per creare una classe interna anonima. Ciò è dovuto alla decisione fondamentale in Java che ogni bit di codice byte deve vivere all'interno di una classe specifica, che non può essere modificata ora dopo decenni di codice legacy da considerare.

Tuttavia, questo non è esattamente ciò di cui parlano le espressioni lambda. Nei formalismi in cui sono concetti nativi piuttosto che una contorsione da salto sul carro, gli lambda sono elementi costitutivi fondamentali; sia la sintassi che l'atteggiamento delle persone nei loro confronti sono molto diversi. L'esempio di una funzione ricorsiva anonima creata esclusivamente da lambda in Struttura e interpretazione dei programmi per computer è in grado di cambiare l'intera concezione del calcolo. (Tuttavia, sono abbastanza certo che il modo di imparare a programmare è solo per esoterico diventare una storia di successo mainstream.)

Sì, è solo uno zucchero sintattico, nel senso che ovunque tu scriva un lambda, puoi riscrivere quell'espressione come un'espressione di classe interna anonima con un metodo, dove la classe implementa l'interfaccia funzionale dedotta per il contesto del lambda, e sarebbe esattamente equivalente semanticamente. E puoi farlo semplicemente sostituendo l'espressione lambda con l'espressione di classe anonima, senza cambiare altre espressioni o righe di codice.

Joachim Sauer ha già fatto un buon lavoro nel rispondere alla tua domanda, ma ha solo accennato a qualcosa che considero importante. Poiché i Lambdas non sono classi, non vengono nemmeno compilati come tali. Tutte le classi interne anonime comportano la creazione di un file .class che a sua volta deve essere caricato da ClassLoader. Quindi l'utilizzo di Lambdas non solo rende il codice più bello, ma riduce anche le dimensioni del codice compilato, l'impronta di memoria del ClassLoader e il tempo necessario per trasferire i bit dal disco rigido.

No non lo sono.

Un altro modo per dirlo è che i lambda sono un modo non orientato agli oggetti, per quanto conciso, per ottenere la stessa cosa che una classe anonima o, la mia preferenza, una classe interiore raggiungerebbe in modo orientato agli oggetti.