Java 8 – Novità introdotte

Java 8 – Novità introdotte

Java 8 è la prima edizione interamente Made in Oracle per cui vi era un’attesa alimentata da dubbi, timori e curiosità derivanti dall’acquisizione della Sun da parte di Oracle. L’attenzione di buona parte della comunità internazionale del software è ora volta a cercare di capire quale sarà l’effettivo supporto della Oracle al mondo Java e alla sua evoluzione, questa major release servirà a delinearne le prospettive. Questa versione prometteva nuove caratteristiche e migliorie in diverse aree funzionali, maggiore produttività degli sviluppatori, incrementi significativi delle prestazioni mediante collezioni e annotazioni migliorate, modelli di programmazione parallela semplificati e utilizzo più efficiente dei processori multi-core.

Sono  stati introdotti diversi miglioramenti nelle raccolta di API java, tra le quali quelle per gli stream la cui performance è stata migliorata. Ma la maggiore novità è l’introduzione delle espressioni Lambda che costituiscono la principale novità per il linguaggio di programmazione Java. Il focus in Java è sempre stato sui dati (classi, ereditarietà, generics, etc.), con questa particolare funzione l’attenzione si muove verso il comportamento.

Si è visto che volendo modellare un flusso del tipo “fai A prima di iniziare, quindi effettua B per ogni file in questo gruppo, C se individui un errore, e infine D quando hai finito“, non vi sono strumenti idonei a esprimere tale comportamento e ciò impatta sulle API, ad esempio costringendo il codice client ad un coinvolgimento diretto in ogni passo.

Le espressioni lambda sono lo strumento individuato per superare questo problema. Sono collegate al concetto di funzione anonima, ossia una funzione che ha un corpo ma non un nome. Un’espressione lambda definisce una funzione anonima che mantiene lo stato. In pratica un metodo senza una dichiarazione e quindi senza nome, modificatori d’accesso, dichiarazione del tipo del valore di ritorno.

La loro sintassi è qualcosa di simile:

(arg1, arg2) -> {body}

Ad esempio:

(int a, int b) -> {return a+b;}

Volendo confrontare codice scritto senza e con le espressioni lambda, osserviamo l’implementazione del comportamento di un pulsante prima e dopo.

//Before:
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Before Java 8");
    }
});
 
//After:
button.addActionListener( (e) -> {
        System.out.println("From Java 8");
});

Di seguito un altro esempio in cui utilizziamo l’espressione lambda per una semplice stampa a video. L’espressione lambda compare due volte, la prima come fatto in precedenza, nella seconda invece vediamo che è possibile convertire un metodo normale in una espressione lambda mediante l’operatore doppio due punti (::).

//Before:
List list1 = Arrays.asList(1,2,3,5);
for(Integer n: list1) {
    System.out.println(n);
}
 
//After:
List list2 = Arrays.asList(1,2,3,5);
list2.forEach(n -> System.out.println(n));
 
//Espressioni lambda e doppio due punti
list2.forEach(System.out::println);

Per informarsi meglio su tutte le novità introdotte, seguite il link per la pagina ufficiale di Oracle.

Category Home, Programmazione