Android e Java 8

Java 8 è stata una delle versioni più innovative del linguaggio che si ricordino. Può essere considerata quella
che ha trasformato Java in un linguaggio "moderno", integrando in esso tutto ciò che riguarda la programmazione funzionale. Al di là delle
notevoli introduzioni tecniche, Java 8 ha portato una sinteticità della sintassi salutata come fattore di maggiore
produttività per il programmatore. È quindi bene analizzare in che modo tutto questo si può applicare nello sviluppo di app Android.

Java 8 e Android Studio

Android Studio 3.0 nasce con il supporto a Java 8 integrato. Il seguente schema - proveniente dalla documentazione
ufficiale - illustra chiaramente che il nuovo meccanismo, detto desugar, interviene tra il compilatore
javac e dex, rielaborando i file .class prodotti dal primo:

Il primo tentativo di utilizzare Java 8 in Android aveva sortito, alcuni anni fa, la cosiddetta Jack toolchain
che è stata più recentemente deprecata con una nota apparsa sull'Android Developers Blog, la quale ammetteva il fallimento
del tentativo presupponendo una via differente per l'integrazione delle specifiche Java 8 nelle app Android.

Per usare Java 8 in Android Studio è necessario:

• integrare ilplugin Android alla versione 3 o superiori nel file build.gradle di progetto;
• innalzare la compatibilità di progetto a Java 8 inserendo nel file build.gradle dei moduli
  che utilizzeranno tali funzionalità direttamente o indirettamente, le direttive targetCompatibility e
  sourceCompatibility:
  

  android {defaultConfig {
  ...
  ...
  }
  buildTypes {
  ...
  ...
  }
  compileOptions {
  targetCompatibility 1.8
  sourceCompatibility 1.8
  }
  }

Compatibilità

Si deve tenere in considerazione anche la versione minima di API Android che supporta le nuove
caratteristiche di Java 8. Alcune di queste possono essere usate con qualsiasi versione di
Android Platform; parliamo di:

• espressioni lambda
• method reference
• metodi statici e di dafault per le interface
• ripetizione di annotazioni

Altre caratteristiche richiedono invece l'impostazione della proprietà minSdkVersion al livello 24 o superiore tra cui,
in particolare, le Stream API (da non
confondere con gli stream di Input/Output), l'annotazione FunctionalInterface e le varie interfacce funzionali definite nel
package java.util.function.

Per i lettori che non avessero dimestichezza con queste funzionalità di Java 8, rimandiamo alla guida a Java di HTML.it, che approfondisce ognuno di questi aspetti con opportuno livello di dettaglio.

Esempi

Passiamo a vedere alcuni esempi. Un caso evidente di utilità delle funzionalità di Java 8 consiste nella sostituzione
degli oggetti di classe anonima con espressioni lambda. Senza queste ultime, per associare un click listener ad un pulsante si
deve procedere nel seguente modo:

Button btn = [...]
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// codice da eseguire al "click"
}
});

La nuova sintassi permette di ridurre tutto al seguente codice:

Button btn = [...]
btn.setOnClickListener((View view) - > {
/* codice da eseguire al "click" */
});

In questo caso, il vantaggio consiste non solo nella riduzione del codice da scrivere ma anche nella sua
semplificazione da un pusto di vista concettuale, richiedendo la scrittura degli elementi minimi necessari al compilatore:
l'argomento di tipo View ed il blocco di codice da eseguire.

Altra introduzione molto interessante di Java 8 sono le Stream API. Possiamo provare anche queste, purché venga innalzato
il livello delle minime API supportate a 24.

Supponiamo di avere a disposizione una lista di oggetti String: vogliamo individuarne la più lunga e stamparla in un Toast
al click di un pulsante. L'evento verrà gestito con una lambda expression mentre per scegliere la stringa da stampare ordineremo
la lista in ordine decrescente di lunghezza estraendone la prima. Quest'ultimo procedimento può essere svolto con l'impiego congiunto di Stream API e method reference:

Button btn = [...]
btn.setOnClickListener((View view) ->
{
String piuLunga=nomi.stream()
.sorted(Comparator.comparing(String::length).reversed())
.findFirst().get();
Toast.makeText(this, piuLunga, Toast.LENGTH_LONG).show();
});

Anche in questo caso, facciamo il confronto con il codice stile Java 7:

btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Collections.sort(nomi, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.length()-o1.length();
}
});
String resp=nomi.get(0);
Toast.makeText(MainActivity.this, resp, Toast.LENGTH_LONG).show();
}
});

Ancora una volta troviamo una sintassi meno prolissa ma soprattutto notiamo la differenza di approccio. Con Java 8
scompare la continua istanziazione di oggetti e la tradizionale estensione di classi mediante override. Il codice
che fa uso di espressioni lambda risulta una concatenazione di invocazioni a metodi che ricostruiscono il procedimento
seguito come una catena di montaggio in cui:

• trasformiamo la lista in stream con nomi.stream();
• ordiniamo i valori sfruttando un Comparator al quale dobbiamo solo indicare che il parametro di confronto è
  la lunghezza della stringa .sorted(Comparator.comparing(String::length).reversed())
• recuperiamo il primo valore della lista così riorganizzata.findFirst().get()

Si noti inoltre che quando abbiamo passato il riferimento al Context al Toast abbiamo usato semplicemente this
con le espressioni lambda mentre senza di essere abbiamo dovuto specificare MainActivity.this a causa dell'ostruzione
di visibilità che gli oggetti di classe anonima operano. Lo svantaggio che il neofita potrebbe ravvisare consisterebbe per lo più
in una leggera cripticità del codice in stile Java 8 man mano che i procedimenti si complicano: niente comunque che un pò di esercizio
non permetta di superare.