Java8 Lambdas vs classi anonime

Dato che Java8 è stato recentemente rilasciato e le sue nuovissime espressioni lambda sembrano davvero interessanti, mi chiedevo se questo significasse la fine delle classi Anonymous a cui eravamo così abituati.

Ho cercato un po 'su questo e ho trovato alcuni esempi interessanti su come le espressioni Lambda sostituiranno sistematicamente quelle classi, come il metodo di ordinamento Collection, che utilizzava per ottenere un'istanza anonima di Comparator per eseguire l'ordinamento:

Collections.sort(personList, new Comparator<Person>(){
  public int compare(Person p1, Person p2){
    return p1.firstName.compareTo(p2.firstName);
  }
});

Ora può essere fatto usando Lambdas:

Collections.sort(personList, (Person p1, Person p2) -> p1.firstName.compareTo(p2.firstName));

E sembra sorprendentemente conciso. Quindi la mia domanda è: c'è qualche motivo per continuare a utilizzare quelle classi in Java8 invece di Lambdas?

MODIFICARE

Stessa domanda ma nella direzione opposta, quali sono i vantaggi dell'utilizzo di Lambdas anziché di classi Anonymous, poiché Lambdas può essere utilizzato solo con interfacce a metodo singolo, questa nuova funzionalità è solo una scorciatoia utilizzata solo in pochi casi o è davvero utile?

Una classe interna anonima (AIC) può essere utilizzata per creare una sottoclasse di una classe astratta o di una classe concreta. Un'AIC può anche fornire un'implementazione concreta di un'interfaccia, inclusa l'aggiunta di stati (campi). È possibile fare riferimento a un'istanza di un AIC utilizzando thisnei suoi corpi del metodo, quindi è possibile richiamare ulteriori metodi, il suo stato può essere mutato nel tempo, ecc. Nessuno di questi si applica ai lambda.

Immagino che la maggior parte degli usi degli AIC fosse quello di fornire implementazioni senza stato di singole funzioni e quindi può essere sostituito con espressioni lambda, ma ci sono altri usi di AIC per i quali non è possibile utilizzare lambda. Gli AIC sono qui per restare.

AGGIORNARE

Un'altra differenza tra gli AIC e le espressioni lambda è che gli AIC introducono un nuovo ambito. Cioè, i nomi vengono risolti dalle superclassi e dalle interfacce dell'AIC e possono nascondere i nomi che si verificano nell'ambiente che racchiude lessicalmente. Per i lambda, tutti i nomi vengono risolti lessicalmente.

Anche se Lambda è un'ottima funzionalità, funziona solo con i tipi SAM. Cioè, si interfaccia con un solo metodo astratto. Non funzionerebbe non appena la tua interfaccia contiene più di 1 metodo astratto. È qui che le classi anonime saranno utili.

Quindi, no, non possiamo semplicemente ignorare le classi anonime. E solo per tua informazione, il tuo sort()metodo può essere più semplificato, saltando la dichiarazione del tipo per p1e p2:

Collections.sort(personList, (p1, p2) -> p1.firstName.compareTo(p2.firstName));

Puoi anche usare il riferimento al metodo qui. O aggiungi un compareByFirstName()metodo in Personclasse e usi:

Collections.sort(personList, Person::compareByFirstName);

oppure, aggiungi un getter per firstName, ottieni direttamente il metodo Comparatorfrom Comparator.comparing():

Collections.sort(personList, Comparator.comparing(Person::getFirstName));

Prestazioni Lambda con classi anonime

Quando l'applicazione viene avviata, ogni file di classe deve essere caricato e verificato.

Le classi anonime vengono elaborate dal compilatore come un nuovo sottotipo per la classe o l'interfaccia data, quindi verrà generato un nuovo file di classe per ciascuna.

I lambda sono diversi nella generazione del bytecode, sono più efficienti, utilizzano istruzioni dinamiche invocate fornite con JDK7.

Per Lambda questa istruzione viene utilizzata per ritardare la traduzione dell'espressione lambda in bytecode fino al runtime. (l'istruzione verrà richiamata solo per la prima volta)

Di conseguenza, l'espressione Lambda diventerà un metodo statico (creato in fase di esecuzione). (C'è una piccola differenza con stateles e statefull case, vengono risolti tramite argomenti del metodo generati)

Ci sono le seguenti differenze:

1) Sintassi

Le espressioni lambda sembrano chiare rispetto a Anonymous Inner Class (AIC)

public static void main(String[] args) {
    Runnable r = new Runnable() {
        @Override
        public void run() {
            System.out.println("in run");
        }
    };

    Thread t = new Thread(r);
    t.start(); 
}

//syntax of lambda expression 
public static void main(String[] args) {
    Runnable r = ()->{System.out.println("in run");};
    Thread t = new Thread(r);
    t.start();
}

2) Ambito di applicazione

Una classe interna anonima è una classe, il che significa che ha l'ambito per la variabile definita all'interno della classe interna.

Considerando che, l' espressione lambda non è un ambito a sé stante, ma fa parte dell'ambito di inclusione.

Una regola simile si applica per super e questa parola chiave quando si utilizza la classe interna anonima e l'espressione lambda. In caso di classe interna anonima, questa parola chiave si riferisce all'ambito locale e la parola chiave super si riferisce alla super classe della classe anonima. Mentre in caso di espressione lambda questa parola chiave si riferisce all'oggetto del tipo che lo racchiude e super farà riferimento alla super classe della classe che lo racchiude.

//AIC
    public static void main(String[] args) {
        final int cnt = 0; 
        Runnable r = new Runnable() {
            @Override
            public void run() {
                int cnt = 5;    
                System.out.println("in run" + cnt);
            }
        };

        Thread t = new Thread(r);
        t.start();
    }

//Lambda
    public static void main(String[] args) {
        final int cnt = 0; 
        Runnable r = ()->{
            int cnt = 5; //compilation error
            System.out.println("in run"+cnt);};
        Thread t = new Thread(r);
        t.start();
    }

3) Prestazioni

In fase di esecuzione le classi interne anonime richiedono il caricamento della classe, l'allocazione della memoria e l'inizializzazione degli oggetti e l'invocazione di un metodo non statico mentre l'espressione lambda è pura attività in fase di compilazione e non comporta costi aggiuntivi durante il runtime. Quindi le prestazioni dell'espressione lambda sono migliori rispetto alle classi interne anonime. **

** Mi rendo conto che questo punto non è del tutto vero. Fare riferimento alla seguente domanda per i dettagli. Lambda vs prestazioni anonime della classe interna: ridurre il carico sul ClassLoader?

Lambda in java 8 è stato introdotto per la programmazione funzionale. Dove puoi evitare il codice boilerplate. Mi sono imbattuto in questo interessante articolo sui lambda.

http://radar.oreilly.com/2014/04/whats-new-in-java-8-lambdas.html

Si consiglia di utilizzare le funzioni lambda per logiche semplici. Se l'implementazione di una logica complessa utilizzando lambda sarà un sovraccarico nel debug del codice in caso di problemi.

Le classi anonime sono lì per restare perché lambda è utile per funzioni con singoli metodi astratti, ma per tutti gli altri casi le classi interne anonime sono il tuo salvatore.

• La sintassi lambda non richiede la scrittura del codice ovvio che Java può dedurre.
• Usando invoke dynamic, lambda non vengono riconvertiti nelle classi anonime durante la compilazione (Java non deve passare attraverso la creazione di oggetti, si preoccupa solo della firma del metodo, può legarsi al metodo senza creare oggetti
• lambda pone maggiormente l'accento su ciò che vogliamo fare invece di ciò che dobbiamo fare prima di poterlo fare