Dieci funzionalità di Kotlin per potenziare lo sviluppo di Android

introduzione

Tempo fa, Tomasz ha introdotto lo sviluppo di Kotlin su Android. Per ricordarti: Kotlin è un nuovo linguaggio di programmazione sviluppato da Jetbrains, l'azienda dietro uno degli IDE Java più popolari, IntelliJ IDEA. Come Java, Kotlin è un linguaggio generico. Poiché è conforme al bytecode JVM (Java Virtual Machine), può essere utilizzato fianco a fianco con Java e non comporta un sovraccarico delle prestazioni.

In questo articolo, tratterò le 10 principali funzionalità utili per potenziare lo sviluppo di Android.

Nota : al momento della stesura di questo articolo, le versioni effettive erano Android Studio 2.1.1. e Kotlin 1.0.2.

Configurazione Kotlin

Poiché Kotlin è sviluppato da JetBrains, è ben supportato sia in Android Studio che in IntelliJ.

Il primo passo è installare il plugin Kotlin. Dopo averlo fatto con successo, saranno disponibili nuove azioni per convertire il tuo Java in Kotlin. Due nuove opzioni sono:

1. Crea un nuovo progetto Android e imposta Kotlin nel progetto.
2. Aggiungi il supporto Kotlin a un progetto Android esistente.

Per sapere come creare un nuovo progetto Android, consulta la guida passo passo ufficiale. Per aggiungere il supporto di Kotlin a un progetto appena creato o esistente, apri la finestra di dialogo Trova azione usando Command + Shift + A su Mac o Ctrl + Shift + A su Windows/Linux e richiama l'azione Configure Kotlin in Project .

Per creare una nuova classe Kotlin, seleziona:

• File > New > Kotlin file/class o
• File > New > Kotlin activity

In alternativa, puoi creare una classe Java e convertirla in Kotlin usando l'azione sopra menzionata. Ricorda, puoi usarlo per convertire qualsiasi classe, interfaccia, enum o annotazione e questo può essere utilizzato per confrontare facilmente Java con il codice Kotlin.

Un altro elemento utile che consente di risparmiare un sacco di digitazione sono le estensioni di Kotlin. Per usarli devi applicare un altro plugin nel tuo file build.gradle del modulo:

 apply plugin: 'kotlin-android-extensions'

Avvertenza : se stai utilizzando l'azione del plug-in Kotlin per impostare il tuo progetto, inserirà il seguente codice nel tuo file build.gradle di livello superiore:

 buildscript { ext.kotlin_version = '1.0.2' repositories { jcenter() } dependencies { classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files } }

Ciò farà sì che l'estensione non funzioni. Per risolvere il problema, copia semplicemente quel codice in ciascuno dei moduli del progetto in cui desideri utilizzare Kotlin.

Se imposti tutto correttamente, dovresti essere in grado di eseguire e testare la tua applicazione nello stesso modo in cui faresti in un progetto Android standard, ma ora usando Kotlin.

Risparmiare tempo con Kotlin

Quindi, iniziamo descrivendo alcuni aspetti chiave del linguaggio Kotlin e fornendo suggerimenti su come risparmiare tempo utilizzandolo al posto di Java.

Caratteristica n. 1: importazione layout statico

Uno dei codici boilerplate più comuni in Android utilizza la funzione findViewById() per ottenere riferimenti alle tue visualizzazioni in Attività o Frammenti.

Ci sono soluzioni, come la libreria Butteknife, che salvano un po' di digitazione, ma Kotlin fa un altro passo permettendoti di importare tutti i riferimenti alle viste dal layout con un'importazione.

Ad esempio, si consideri il seguente layout XML dell'attività:

 <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:andro xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:paddingBottom="@dimen/activity_vertical_margin" android:paddingLeft="@dimen/activity_horizontal_margin" android:paddingRight="@dimen/activity_horizontal_margin" android:paddingTop="@dimen/activity_vertical_margin" tools:context="co.ikust.kotlintest.MainActivity"> <TextView android: android:layout_width="wrap_content" android:layout_height="wrap_content"/> </RelativeLayout>

E il codice attività di accompagnamento:

 package co.ikust.kotlintest import android.support.v7.app.AppCompatActivity import android.os.Bundle import kotlinx.android.synthetic.main.activity_main.* class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) helloWorldTextView.text = "Hello World!" } }

Per ottenere i riferimenti per tutte le viste nel layout con un ID definito, utilizzare l'estensione Android Kotlin Anko. Ricordarsi di digitare questa dichiarazione di importazione:

 import kotlinx.android.synthetic.main.activity_main.*

Nota che non è necessario scrivere punti e virgola alla fine delle righe in Kotlin perché sono facoltativi.

Il TextView dal layout viene importato come un'istanza TextView con il nome uguale all'ID della vista. Non lasciarti confondere dalla sintassi, che viene utilizzata per impostare l'etichetta:

 helloWorldTextView.text = "Hello World!"

Lo tratteremo a breve.

Avvertenze :

• Assicurati di importare il layout corretto, altrimenti i riferimenti di visualizzazione importati avranno un valore null .
• Quando si utilizzano frammenti, assicurarsi che i riferimenti di visualizzazione importati vengano utilizzati dopo la chiamata alla funzione onCreateView() . Importa il layout nella funzione onCreateView() e utilizza i riferimenti Visualizza per configurare l'interfaccia utente in onViewCreated() . I riferimenti non verranno assegnati prima che il metodo onCreateView() sia terminato.

Caratteristica n. 2: scrivere lezioni POJO con Kotlin

Qualcosa che farà risparmiare più tempo con Kotlin sta scrivendo le classi POJO (Plain Old Java Object) utilizzate per contenere i dati. Ad esempio, nel corpo della richiesta e della risposta di un'API RESTful. Nelle applicazioni che si basano sull'API RESTful, ci saranno molte classi del genere.

In Kotlin, molto è stato fatto per te e la sintassi è concisa. Ad esempio, considera la seguente classe in Java:

 public class User { private String firstName; private String lastName; public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } }

Quando si lavora con Kotlin, non è necessario scrivere di nuovo una parola chiave pubblica. Per impostazione predefinita, tutto è di portata pubblica. Ad esempio, se vuoi dichiarare una classe, scrivi semplicemente:

 class MyClass { }

L'equivalente del codice Java sopra in Kotlin:

 class User { var firstName: String? = null var lastName: String? = null }

Bene, questo consente di risparmiare un sacco di digitazione, vero? Esaminiamo il codice Kotlin.

Quando si definiscono le variabili in Kotlin, ci sono due opzioni:

• Variabili mutabili, definite dalla parola chiave var .
• Variabili immutabili, definite dalla parola chiave val .

La prossima cosa da notare è che la sintassi è leggermente diversa da Java; prima dichiari il nome della variabile e poi segui type. Inoltre, per impostazione predefinita, le proprietà sono tipi non null, il che significa che non possono accettare valori null . Per definire una variabile che accetti un valore null , è necessario aggiungere un punto interrogativo dopo il tipo. Parleremo di questo e della sicurezza nulla in Kotlin in seguito.

Un'altra cosa importante da notare è che Kotlin non ha la capacità di dichiarare campi per la classe; possono essere definite solo le proprietà. Quindi, in questo caso, firstName e lastName sono proprietà a cui sono stati assegnati metodi getter/setter predefiniti. Come accennato, in Kotlin sono entrambi pubblici per impostazione predefinita.

È possibile scrivere accessori personalizzati, ad esempio:

 class User { var firstName: String? = null var lastName: String? = null val fullName: String? get() firstName + " " + lastName }

Dall'esterno, quando si tratta di sintassi, le proprietà si comportano come campi pubblici in Java:

 val userName = user.firstName user.firstName = "John"

Si noti che la nuova proprietà fullName è di sola lettura (definita dalla parola chiave val ) e ha un getter personalizzato; aggiunge semplicemente nome e cognome.

Tutte le proprietà in Kotlin devono essere assegnate quando dichiarate o sono in un costruttore. Ci sono alcuni casi in cui non è conveniente; ad esempio, per le proprietà che verranno inizializzate tramite inserimento delle dipendenze. In tal caso, è possibile utilizzare un modificatore lateinit . Ecco un esempio:

 class MyClass { lateinit var firstName : String; fun inject() { firstName = "John"; } }

Maggiori dettagli sulle proprietà possono essere trovati nella documentazione ufficiale.

Caratteristica n. 3: Ereditarietà di classe e Costruttori

Kotlin ha anche una sintassi più concisa quando si tratta di costruttori.

Costruttori

Le classi Kotlin hanno un costruttore primario e uno o più costruttori secondari. Un esempio di definizione di un costruttore primario:

 class User constructor(firstName: String, lastName: String) { }

Il costruttore primario va dopo il nome della classe nella definizione della classe. Se il costruttore principale non ha annotazioni o modificatori di visibilità, la parola chiave costruttore può essere omessa:

 class Person(firstName: String) { }

Si noti che un costruttore primario non può avere alcun codice; qualsiasi inizializzazione deve essere eseguita nel blocco di codice init :

 class Person(firstName: String) { init { //perform primary constructor initialization here } }

Inoltre, un costruttore primario può essere utilizzato per definire e inizializzare le proprietà:

 class User(var firstName: String, var lastName: String) { // ... }

Proprio come quelle normali, le proprietà definite da un costruttore primario possono essere immutabili ( val ) o mutabili ( var ).

Le classi possono avere anche costruttori secondari; la sintassi per definirne uno è la seguente:

 class User(var firstName: String, var lastName) { constructor(name: String, parent: Person) : this(name) { parent.children.add(this) } }

Si noti che ogni costruttore secondario deve delegare a un costruttore primario. Questo è simile a Java, che usa this parola chiave:

 class User(val firstName: String, val lastName: String) { constructor(firstName: String) : this(firstName, "") { //... } }

Quando si istanziano le classi, si noti che Kotlin non ha new parole chiave, così come Java. Per istanziare la suddetta classe User , utilizzare:

 val user = User("John", "Doe)

Presentazione dell'ereditarietà

In Kotlin, tutte le classi si estendono da Any , che è simile a Object in Java. Per impostazione predefinita, le classi sono chiuse, come le classi finali in Java. Quindi, per estendere una classe, deve essere dichiarata open o abstract :

 open class User(val firstName, val lastName) class Administrator(val firstName, val lastName) : User(firstName, lastName)

Nota che devi delegare al costruttore predefinito della classe estesa, che è simile alla chiamata del metodo super() nel costruttore di una nuova classe in Java.

Per maggiori dettagli sulle classi, controlla la documentazione ufficiale.

Caratteristica n. 4: Espressioni Lambda

Le espressioni Lambda, introdotte con Java 8, sono una delle sue caratteristiche preferite. Tuttavia, le cose non sono così brillanti su Android, poiché supporta ancora solo Java 7 e sembra che Java 8 non sarà supportato a breve. Quindi, soluzioni alternative, come Retrolambda, portano le espressioni lambda su Android.

Con Kotlin, non sono necessarie librerie aggiuntive o soluzioni alternative.

Funzioni in Kotlin

Iniziamo esaminando rapidamente la sintassi della funzione in Kotlin:

 fun add(x: Int, y: Int) : Int { return x + y }

Il valore di ritorno della funzione può essere omesso e, in tal caso, la funzione restituirà Int . Vale la pena ripetere che tutto in Kotlin è un oggetto, esteso da Any , e non ci sono tipi primitivi.

Un argomento della funzione può avere un valore predefinito, ad esempio:

 fun add(x: Int, y: Int = 1) : Int { return x + y; }

In tal caso, la funzione add() può essere invocata passando solo l'argomento x . Il codice Java equivalente sarebbe:

 int add(int x) { Return add(x, 1); } int add(int x, int y) { return x + y; }

Un'altra cosa interessante quando si chiama una funzione è che è possibile utilizzare argomenti con nome. Per esempio:

 add(y = 12, x = 5)

Per maggiori dettagli sulle funzioni, consultare la documentazione ufficiale.

Utilizzo delle espressioni Lambda in Kotlin

Le espressioni Lambda in Kotlin possono essere viste come funzioni anonime in Java, ma con una sintassi più concisa. Ad esempio, mostriamo come implementare click listener in Java e Kotlin.

In Java:

 view.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Toast.makeText(v.getContext(), "Clicked on view", Toast.LENGTH_SHORT).show(); } };

In Kotlin:

 view.setOnClickListener({ view -> toast("Click") })

Oh! Solo una riga di codice! Possiamo vedere che l'espressione lambda è racchiusa tra parentesi graffe. I parametri vengono dichiarati per primi e il corpo va dopo il segno -> . Con il listener di clic, il tipo per il parametro di visualizzazione non è specificato poiché può essere dedotto. Il corpo è semplicemente una chiamata alla funzione toast() per mostrare toast, fornita da Kotlin.

Inoltre, se i parametri non vengono utilizzati, possiamo ometterli:

 view.setOnClickListener({ toast("Click") })

Kotlin ha ottimizzato le librerie Java e qualsiasi funzione che riceve un'interfaccia con un metodo per un argomento può essere chiamata con un argomento di funzione (invece di Interface).

Inoltre, se la funzione è l'ultimo parametro, può essere spostato fuori dalle parentesi:

 view.setOnClickListener() { toast("Click") }

Infine, se la funzione ha un solo parametro che è una funzione, le parentesi possono essere omesse:

 view.setOnClickListener { toast("Click") }

Per ulteriori informazioni, consulta il libro degli sviluppatori Kotlin per Android di Antonio Leiva e la documentazione ufficiale.

Funzioni di estensione

Kotlin, simile a C#, offre la possibilità di estendere le classi esistenti con nuove funzionalità usando le funzioni di estensione. Ad esempio, un metodo di estensione che calcolerebbe l'hash MD5 di una String :

 fun String.md5(): ByteArray { val digester = MessageDigest.getInstance("MD5") digester.update(this.toByteArray(Charset.defaultCharset())) return digester.digest() }

Si noti che il nome della funzione è preceduto dal nome della classe estesa (in questo caso, String ) e che l'istanza della classe estesa è disponibile tramite this parola chiave.

Le funzioni di estensione sono l'equivalente delle funzioni di utilità Java. La funzione di esempio in Java sarebbe simile a:

 public static int toNumber(String instance) { return Integer.valueOf(instance); }

La funzione di esempio deve essere inserita in una classe Utility. Ciò significa che le funzioni di estensione non modificano la classe estesa originale, ma sono un modo conveniente per scrivere metodi di utilità.

Caratteristica n. 5: sicurezza nulla

Una delle cose che ti affretti di più in Java è probabilmente NullPointerException . La sicurezza nulla è una funzionalità che è stata integrata nel linguaggio Kotlin ed è così implicita di cui di solito non dovrai preoccuparti. La documentazione ufficiale afferma che le uniche possibili cause di NullPointerExceptions sono:

• Una chiamata esplicita per lanciare NullPointerException .
• Usando il !! operatore (che spiegherò più avanti).
• Codice Java esterno.
• Se si accede alla proprietà lateinit nel costruttore prima che venga inizializzata, verrà generata UninitializedPropertyAccessException .

Per impostazione predefinita, tutte le variabili e le proprietà in Kotlin sono considerate non-null (incapaci di contenere un valore null ) se non sono dichiarate esplicitamente come nullable. Come già accennato, per definire una variabile che accetti un valore null , è necessario aggiungere un punto interrogativo dopo il tipo. Per esempio:

 val number: Int? = null

Tuttavia, tieni presente che il codice seguente non verrà compilato:

 val number: Int? = null number.toString()

Questo perché il compilatore esegue controlli null . Per compilare, è necessario aggiungere un controllo null :

 val number: Int? = null if(number != null) { number.toString(); }

Questo codice verrà compilato correttamente. Quello che Kotlin fa in background, in questo caso, è che il number diventa nun-null ( Int invece di Int? ) all'interno del blocco if.

Il controllo null può essere semplificato utilizzando l'operatore di chiamata sicura ( ?. ):

 val number: Int? = null number?.toString()

La seconda riga verrà eseguita solo se il numero non è null . Puoi anche usare il famoso operatore di Elvis ( ?: ):

 val number Int? = null val stringNumber = number?.toString() ?: "Number is null"

Se l'espressione a sinistra di ?: non è null , viene valutata e restituita. In caso contrario, viene restituito il risultato dell'espressione a destra. Un'altra cosa interessante è che puoi usare throw o return sul lato destro dell'operatore di Elvis poiché sono espressioni in Kotlin. Per esempio:

 fun sendMailToUser(user: User) { val email = user?.email ?: throw new IllegalArgumentException("User email is null") //... }

Il !! Operatore

Se vuoi che una NullPointerException lanciata allo stesso modo di Java, puoi farlo con !! operatore. Il codice seguente genererà NullPointerException :

 val number: Int? = null number!!.toString()

Casting

Casting fatto usando una parola chiave as :

 val x: String = y as String

Questo è considerato cast "non sicuro", poiché genererà ClassCastException se il cast non è possibile, come fa Java. Esiste un operatore di cast "sicuro" che restituisce il valore null invece di generare un'eccezione:

 val x: String = y as? String

Per maggiori dettagli sul casting, controlla la sezione Type Casts and Casts della documentazione ufficiale e per maggiori dettagli sulla sicurezza null controlla la sezione Null-Safety.

proprietà lateinit

C'è un caso in cui l'uso delle proprietà lateinit può causare un'eccezione simile a NullPointerException . Considera la seguente classe:

 class InitTest { lateinit var s: String; init { val len = this.s.length } }

Questo codice verrà compilato senza preavviso. Tuttavia, non appena viene creata un'istanza di TestClass , verrà generata UninitializedPropertyAccessException perché si accede alla proprietà s prima che venga inizializzata.

Caratteristica n. 6: funzione with()

La funzione with() è utile e viene fornita con la libreria standard Kotlin. Può essere utilizzato per salvare alcune digitazioni se è necessario accedere a molte proprietà di un oggetto. Per esempio:

 with(helloWorldTextView) { text = "Hello World!" visibility = View.VISIBLE }

Riceve un oggetto e una funzione di estensione come parametri. Il blocco di codice (tra parentesi graffe) è un'espressione lambda per la funzione di estensione dell'oggetto specificato come primo parametro.

Caratteristica n. 7: sovraccarico dell'operatore

Con Kotlin, è possibile fornire implementazioni personalizzate per un insieme predefinito di operatori. Per implementare un operatore, è necessario fornire una funzione membro o una funzione di estensione con il nome specificato.

Ad esempio, per implementare l'operatore di moltiplicazione, è necessario fornire una funzione membro o una funzione di estensione, con il nome times(argument) :

 operator fun String.times(b: Int): String { val buffer = StringBuffer() for (i in 1..b) { buffer.append(this) } return buffer.toString() }

L'esempio precedente mostra un'implementazione dell'operatore binary * su String . Ad esempio, la seguente espressione assegnerà il valore "TestTestTestTest" a una variabile newString :

 val newString = "Test" * 4

Poiché è possibile utilizzare le funzioni di estensione, significa che è possibile modificare il comportamento predefinito degli operatori per tutti gli oggetti. Questa è un'arma a doppio taglio e dovrebbe essere usata con cautela. Per un elenco dei nomi delle funzioni per tutti gli operatori che possono essere sovraccaricati, consultare la documentazione ufficiale.

Un'altra grande differenza rispetto a Java sono gli operatori == e != . Operatore == traduce in:

 a?.equals(b) ?: b === null

Mentre l'operatore != traduce in:

 !(a?.equals(b) ?:

Ciò significa che l'utilizzo di == non esegue un controllo dell'identità come in Java (confronta se le istanze di un oggetto sono le stesse), ma si comporta allo stesso modo del metodo equals() insieme ai controlli null .

Per eseguire il controllo dell'identità, in Kotlin devono essere utilizzati gli operatori === e !== .

Caratteristica n. 8: proprietà delegate

Alcune proprietà condividono alcuni comportamenti comuni. Per esempio:

• Proprietà inizializzate in modo pigro che vengono inizializzate al primo accesso.
• Proprietà che implementano il modello Osservabile in Observer.
• Proprietà memorizzate in una mappa invece come campi separati.

Per semplificare l'implementazione di casi come questo, Kotlin supporta le proprietà delegate :

 class SomeClass { var p: String by Delegate() }

Ciò significa che le funzioni getter e setter per la proprietà p sono gestite da un'istanza di un'altra classe, Delegate .

Un esempio di delegato per la proprietà String :

 class Delegate { operator fun getValue(thisRef: Any?, property: KProperty<*>): String { return "$thisRef, thank you for delegating '${property.name}' to me!" } operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) { println("$value has been assigned to '${property.name} in $thisRef.'") } }

L'esempio precedente stampa un messaggio quando una proprietà viene assegnata o letta.

I delegati possono essere creati sia per le proprietà mutabili ( var ) che di sola lettura ( val ).

Per una proprietà di sola lettura, è necessario implementare il metodo getValue . Richiede due parametri (presi dalla documentazione ufficiale):

• ricevitore - deve essere lo stesso o un supertipo del proprietario della proprietà (per le proprietà di estensione, è il tipo che viene esteso).
• metadata - deve essere di tipo KProperty<*> o il suo supertipo.

Questa funzione deve restituire lo stesso tipo della proprietà o il suo sottotipo.

Per una proprietà mutabile, un delegato deve fornire inoltre una funzione denominata setValue che accetta i parametri seguenti:

• ricevitore - come per getValue() .
• metadati - come per getValue() .
• nuovo valore - deve essere dello stesso tipo di una proprietà o del suo supertipo.

Ci sono alcuni delegati standard forniti con Kotlin che coprono le situazioni più comuni:

• Pigro
• Osservabile
• Veto

Pigro

Lazy è un delegato standard che accetta un'espressione lambda come parametro. L'espressione lambda passata viene eseguita la prima volta che viene chiamato il metodo getValue() .

Per impostazione predefinita, la valutazione delle proprietà pigre è sincronizzata. Se non sei interessato al multithreading, puoi utilizzare lazy(LazyThreadSafetyMode.NONE) { … } per ottenere prestazioni extra.

Osservabile

Delegates.observable() è per le proprietà che dovrebbero comportarsi come osservabili nel modello Observer. Accetta due parametri, il valore iniziale e una funzione con tre argomenti (proprietà, vecchio valore e nuovo valore).

L'espressione lambda data verrà eseguita ogni volta che viene chiamato il metodo setValue() :

 class User { var email: String by Delegates.observable("") { prop, old, new -> //handle the change from old to new value } }

Veto

Questo delegato standard è un tipo speciale di osservabile che consente di decidere se un nuovo valore assegnato a una proprietà verrà archiviato o meno. Può essere utilizzato per verificare alcune condizioni prima di assegnare un valore. Come con Delegates.observable() , accetta due parametri: il valore iniziale e una funzione.

La differenza è che la funzione restituisce un valore booleano. Se restituisce true , il nuovo valore assegnato alla proprietà verrà archiviato o altrimenti eliminato.

 var positiveNumber = Delegates.vetoable(0) { d, old, new -> new >= 0 }

L'esempio fornito memorizzerà solo i numeri positivi assegnati alla proprietà.

Per maggiori dettagli, controlla la documentazione ufficiale.

Caratteristica n. 9: mappatura di un oggetto su una mappa

Un caso d'uso comune consiste nel memorizzare i valori delle proprietà all'interno di una mappa. Ciò accade spesso nelle applicazioni che funzionano con le API RESTful e analizzano gli oggetti JSON. In questo caso, un'istanza della mappa può essere utilizzata come delegato per una proprietà delegata. Un esempio dalla documentazione ufficiale:

 class User(val map: Map<String, Any?>) { val name: String by map val age: Int by map }

In questo esempio, User ha un costruttore primario che accetta una mappa. Le due proprietà prenderanno i valori dalla mappa mappati in chiavi uguali ai nomi delle proprietà:

 val user = User(mapOf( "name" to "John Doe", "age" to 25 ))

Alla proprietà name della nuova istanza utente verrà assegnato il valore di "John Doe" e alla proprietà age il valore 25.

Funziona anche per le proprietà var in combinazione con MutableMap :

 class MutableUser(val map: MutableMap<String, Any?>) { var name: String by map var age: Int by map }

Caratteristica n. 10: raccolte e operazioni funzionali

Con il supporto per lambda in Kotlin, le raccolte possono essere sfruttate a un nuovo livello.

Prima di tutto, Kotlin distingue tra collezioni mutabili e immutabili. Ad esempio, esistono due versioni dell'interfaccia Iterable :

• Iterabile
• Mutevole Iterabile

Lo stesso vale per le interfacce Collection , List , Set e Map .

Ad esempio, questa any operazione restituisce true se almeno un elemento corrisponde al predicato specificato:

 val list = listOf(1, 2, 3, 4, 5, 6) assertTrue(list.any { it % 2 == 0 })

Per un elenco completo di operazioni funzionali che possono essere eseguite sulle raccolte, controlla questo post del blog.

Conclusione

Abbiamo appena scalfito la superficie di ciò che offre Kotlin. Per chi fosse interessato ad approfondire e saperne di più, controlla:

• Post e libro sul blog di Kotlin di Antonio Leiva.
• Documentazione ufficiale e tutorial di JetBrains.

Per riassumere, Kotlin ti offre la possibilità di risparmiare tempo durante la scrittura di applicazioni Android native utilizzando una sintassi intuitiva e concisa. È ancora un linguaggio di programmazione giovane, ma secondo me ora è abbastanza stabile da poter essere utilizzato per la creazione di app di produzione.

I vantaggi dell'utilizzo di Kotlin:

• Il supporto di Android Studio è perfetto ed eccellente.
• È facile convertire un progetto Java esistente in Kotlin.
• Il codice Java e Kotlin può coesistere nello stesso progetto.
• Non vi è alcun sovraccarico di velocità nell'applicazione.

Gli svantaggi:

• Kotlin aggiungerà le sue librerie al .apk generato, quindi la dimensione finale del .apk sarà di circa 300 KB più grande.
• In caso di abuso, il sovraccarico dell'operatore può portare a codice illeggibile.
• IDE e Autocomplete si comportano un po' più lentamente quando si lavora con Kotlin rispetto ai progetti Java Android puri.
• I tempi di compilazione possono essere un po' più lunghi.