introduction

Il y a un moment, Tomasz a présenté le développement de Kotlin sur Android . Pour vous rappeler: Kotlin est un nouveau langage de programmation développé par Jetbrains , la société à l'origine de l'un des IDE Java les plus populaires, IDÉE IntelliJ . Comme Java, Kotlin est un langage polyvalent. Puisqu'il est conforme au bytecode de la machine virtuelle Java (JVM), il peut être utilisé côte à côte avec Java, et il n'entraîne pas de surcharge de performances.

Dans cet article, je vais couvrir les 10 principales fonctionnalités utiles pour booster votre développement Android.

Remarque : au moment de la rédaction de cet article, les versions actuelles étaient Android Studio 2.1.1. et Kotlin 1.0.2.

Vous en avez assez du code Java sans fin? Essayez Kotlin et économisez votre temps et votre santé mentale. Tweet

Configuration de Kotlin

Puisque Kotlin est développé par JetBrains, il est bien pris en charge dans Android Studio et IntelliJ.

La première étape consiste à installer le plugin Kotlin . Une fois cette opération effectuée, de nouvelles actions seront disponibles pour convertir votre Java en Kotlin. Deux nouvelles options sont:

1. Créez un nouveau projet Android et configurez Kotlin dans le projet.
2. Ajoutez la prise en charge de Kotlin à un projet Android existant.

Pour savoir comment créer un nouveau projet Android, consultez la guide officiel étape par étape . Pour ajouter la prise en charge de Kotlin à un projet nouvellement créé ou existant, ouvrez le rechercher une boîte de dialogue d'action en utilisant Command + Shift + A sur Mac ou Ctrl + Shift + A sous Windows / Linux, et appelez Configure Kotlin in Project action.

Pour créer une nouvelle classe Kotlin, sélectionnez:

• File > New > Kotlin file/class, ou
• File > New > Kotlin activity

Vous pouvez également créer une classe Java et la convertir en Kotlin en utilisant l'action mentionnée ci-dessus. N'oubliez pas que vous pouvez l'utiliser pour convertir n'importe quelle classe, interface, énumération ou annotation, et cela peut être utilisé pour comparer facilement Java au code Kotlin.

Les extensions Kotlin sont un autre élément utile qui économise beaucoup de frappe. Pour les utiliser, vous devez appliquer un autre plugin dans votre module build.gradle fichier:

apply plugin: 'kotlin-android-extensions'

Caveat : si vous utilisez l'action du plugin Kotlin pour configurer votre projet, il mettra le code suivant dans votre niveau supérieur build.gradle fichier:

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 } }

Cela empêchera l'extension de fonctionner. Pour résoudre ce problème, copiez simplement ce code dans chacun des modules de projet dans lesquels vous souhaitez utiliser Kotlin.

Si vous configurez tout correctement, vous devriez pouvoir exécuter et tester votre application de la même manière que vous le feriez dans un projet Android standard, mais en utilisant maintenant Kotlin.

Gagner du temps avec Kotlin

Commençons donc par décrire certains aspects clés du langage Kotlin et en fournissant des conseils sur la façon dont vous pouvez gagner du temps en l’utilisant à la place de Java.

Fonctionnalité n ° 1: importation de mise en page statique

L'un des codes passe-partout les plus courants dans Android utilise le findViewById() pour obtenir des références à vos vues dans Activités ou Fragments.

Il existe des solutions, telles que Couteau à beurre bibliothèque, qui économise un peu de frappe, mais Kotlin franchit une autre étape en vous permettant d'importer toutes les références aux vues de la mise en page avec une importation.

Par exemple, considérez la disposition XML d'activité suivante:

comment utiliser twitter api python

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!' } }

Et le code d'activité qui l'accompagne:

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

Pour obtenir les références de toutes les vues de la mise en page avec un ID défini, utilisez l'extension Android Kotlin Anko . N'oubliez pas de taper cette instruction d'importation:

TextView

Notez que vous n'avez pas besoin d'écrire des points-virgules à la fin des lignes dans Kotlin car ils sont facultatifs.

Le TextView à partir de la mise en page est importé sous forme de helloWorldTextView.text = 'Hello World!' instance avec le nom égal à l'ID de la vue. Ne vous méprenez pas sur la syntaxe utilisée pour définir le libellé:

null

Nous couvrirons cela sous peu.

Mises en garde :

• Assurez-vous d'importer la mise en page correcte, sinon les références de vue importées auront un onCreateView() valeur.
• Lorsque vous utilisez des fragments, assurez-vous que les références de vue importées sont utilisées après le onCreateView() appel de fonction. Importez la mise en page dans onViewCreated() et utilisez les références View pour configurer l'interface utilisateur dans onCreateView(). Les références ne seront pas attribuées avant le 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; } } la méthode est terminée.

Fonctionnalité n ° 2: Ecrire des cours POJO avec Kotlin

Quelque chose qui fera gagner le plus de temps avec Kotlin est l'écriture des classes POJO (Plain Old Java Object) utilisées pour contenir des données. Par exemple, dans le corps de la requête et de la réponse d'une API RESTful. Dans les applications qui reposent sur l'API RESTful, il y aura de nombreuses classes comme ça.

Dans Kotlin, beaucoup est fait pour vous et la syntaxe est concise. Par exemple, considérez la classe suivante en Java:

class MyClass { }

Lorsque vous travaillez avec Kotlin, vous n’avez pas besoin de réécrire un mot-clé public. Par défaut, tout est de portée publique. Par exemple, si vous souhaitez déclarer une classe, vous écrivez simplement:

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

L'équivalent du code Java ci-dessus dans Kotlin:

var

Eh bien, cela économise beaucoup de saisie, n'est-ce pas? Passons en revue le code Kotlin.

Lors de la définition de variables dans Kotlin, il existe deux options:

• Variables mutables, définies par val mot-clé.
• Variables immuables, définies par null mot-clé.

La prochaine chose à noter est que la syntaxe diffère un peu de Java; tout d'abord, vous déclarez le nom de la variable, puis suivez avec type. De plus, par défaut, les propriétés sont de type non nul, ce qui signifie qu’elles ne peuvent pas accepter null valeur. Pour définir une variable pour accepter un firstName valeur, un point d'interrogation doit être ajouté après le type. Nous parlerons de cela et de la sécurité nulle à Kotlin plus tard.

Une autre chose importante à noter est que Kotlin n’a pas la possibilité de déclarer des champs pour la classe; seules les propriétés peuvent être définies. Donc, dans ce cas, lastName et class User { var firstName: String? = null var lastName: String? = null val fullName: String? get() firstName + ' ' + lastName } sont des propriétés auxquelles les méthodes getter / setter par défaut ont été affectées. Comme mentionné, à Kotlin, ils sont tous deux publics par défaut.

Les accesseurs personnalisés peuvent être écrits, par exemple:

val userName = user.firstName user.firstName = 'John'

De l'extérieur, en matière de syntaxe, les propriétés se comportent comme des champs publics en Java:

fullName

Notez que la nouvelle propriété val est en lecture seule (défini par le mot-clé lateinit) et possède un getter personnalisé; il ajoute simplement le prénom et le nom.

Toutes les propriétés de Kotlin doivent être affectées lorsqu'elles sont déclarées ou se trouvent dans un constructeur. Dans certains cas, ce n’est pas pratique; par exemple, pour les propriétés qui seront initialisées via l'injection de dépendances. Dans ce cas, a class MyClass { lateinit var firstName : String; fun inject() { firstName = 'John'; } } un modificateur peut être utilisé. Voici un exemple:

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

Plus de détails sur les propriétés peuvent être trouvés dans le documentation officielle .

Fonctionnalité n ° 3: héritage de classe et constructeurs

Kotlin a également une syntaxe plus concise en ce qui concerne les constructeurs.

Constructeurs

Les classes Kotlin ont un constructeur principal et un ou plusieurs constructeurs secondaires. Un exemple de définition d'un constructeur principal:

class Person(firstName: String) { }

Le constructeur principal suit le nom de la classe dans la définition de classe. Si le constructeur principal n'a pas d'annotations ou de modificateurs de visibilité, le mot-clé constructeur peut être omis:

init

Notez qu'un constructeur principal ne peut pas avoir de code; toute initialisation doit être effectuée dans le class Person(firstName: String) { init { //perform primary constructor initialization here } } bloc de code:

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

De plus, un constructeur principal peut être utilisé pour définir et initialiser les propriétés:

val

Tout comme les propriétés normales, les propriétés définies à partir d'un constructeur principal peuvent être immuables (var) ou mutables (class User(var firstName: String, var lastName) { constructor(name: String, parent: Person) : this(name) { parent.children.add(this) } } ).

Les classes peuvent également avoir des constructeurs secondaires; la syntaxe pour en définir un est la suivante:

this

Notez que chaque constructeur secondaire doit déléguer à un constructeur principal. Ceci est similaire à Java, qui utilise class User(val firstName: String, val lastName: String) { constructor(firstName: String) : this(firstName, '') { //... } } mot-clé:

new

Lors de l'instanciation de classes, notez que Kotlin n'a pas User mots-clés, tout comme Java. Pour instancier le val user = User('John', 'Doe) classe, utilisez:

Any

Présentation de l'héritage

Dans Kotlin, toutes les classes s'étendent de Object, qui est similaire à open en Java. Par défaut, les classes sont fermées, comme les classes finales en Java. Ainsi, pour étendre une classe, elle doit être déclarée comme abstract ou open class User(val firstName, val lastName) class Administrator(val firstName, val lastName) : User(firstName, lastName) :

super()

Notez que vous devez déléguer au constructeur par défaut de la classe étendue, qui est similaire à l'appel de fun add(x: Int, y: Int) : Int { return x + y } méthode dans le constructeur d'une nouvelle classe en Java.

Pour plus de détails sur les cours, consultez la documentation officielle .

Fonctionnalité n ° 4: Expressions Lambda

Les expressions Lambda, introduites avec Java 8, sont l'une de ses fonctionnalités préférées. Cependant, les choses ne sont pas si brillantes sur Android, car il ne prend toujours en charge que Java 7, et il semble que Java 8 ne sera pas pris en charge de sitôt. Donc, des solutions de contournement, telles que Retrolambda , apportez des expressions lambda à Android.

Avec Kotlin, aucune bibliothèque ou solution de contournement supplémentaire n'est requise.

Fonctions dans Kotlin

Commençons par passer rapidement en revue la syntaxe de la fonction dans Kotlin:

Int

La valeur de retour de la fonction peut être omise, et dans ce cas, la fonction renverra Any. Il vaut la peine de répéter que tout dans Kotlin est un objet, étendu de fun add(x: Int, y: Int = 1) : Int { return x + y; } , et qu'il n'y a pas de types primitifs.

Un argument de la fonction peut avoir une valeur par défaut, par exemple:

add()

Dans ce cas, le x La fonction peut être appelée en transmettant uniquement int add(int x) { Return add(x, 1); } int add(int x, int y) { return x + y; } argument. Le code Java équivalent serait:

add(y = 12, x = 5)

Une autre bonne chose lors de l'appel d'une fonction est que des arguments nommés peuvent être utilisés. Par exemple:

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

Pour plus de détails sur les fonctions, consultez la documentation officielle .

qu'est-ce que l'exposition au risque de change ?

Utilisation d'expressions Lambda dans Kotlin

Les expressions Lambda dans Kotlin peuvent être considérées comme des fonctions anonymes en Java, mais avec une syntaxe plus concise. À titre d'exemple, voyons comment implémenter l'écouteur de clics dans Java et Kotlin.

En Java:

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

À Kotlin:

->

Hou la la! Juste une ligne de code! Nous pouvons voir que l'expression lambda est entourée d'accolades. Les paramètres sont déclarés en premier et le corps suit le toast() signe. Avec l'écouteur de clics, le type du paramètre d'affichage n'est pas spécifié car il peut être déduit. Le corps est simplement un appel à view.setOnClickListener({ toast('Click') }) fonction pour montrer des toasts, que Kotlin fournit.

De plus, si les paramètres ne sont pas utilisés, nous pouvons les omettre:

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

Kotlin a optimisé des bibliothèques Java, et toute fonction qui reçoit une interface avec une méthode pour un argument peut être appelée avec un argument de fonction (au lieu d'Interface).

De plus, si la fonction est le dernier paramètre, elle peut être déplacée hors des parenthèses:

view.setOnClickListener { toast('Click') }

Enfin, si la fonction n'a qu'un seul paramètre qui est une fonction, les parenthèses peuvent être omises:

String

Pour plus d'informations, consultez Livre Kotlin pour les développeurs Android par Antonio Leiva et le documentation officielle .

Fonctions d'extension

Kotlin, similaire à C #, offre la possibilité d'étendre les classes existantes avec de nouvelles fonctionnalités en utilisant des fonctions d'extension. Par exemple, une méthode d'extension qui calculerait le hachage MD5 d'un fun String.md5(): ByteArray { val digester = MessageDigest.getInstance('MD5') digester.update(this.toByteArray(Charset.defaultCharset())) return digester.digest() } :

String

Notez que le nom de la fonction est précédé du nom de la classe étendue (dans ce cas, this), et que l'instance de la classe étendue est disponible via public static int toNumber(String instance) { return Integer.valueOf(instance); } mot-clé.

Les fonctions d'extension sont l'équivalent des fonctions utilitaires Java. L'exemple de fonction en Java ressemblerait à ceci:

NullPointerException

L'exemple de fonction doit être placé dans une classe Utility. Cela signifie que les fonctions d'extension ne modifient pas la classe étendue d'origine, mais constituent un moyen pratique d'écrire des méthodes utilitaires.

Caractéristique n ° 5: sécurité nulle

L'une des choses que vous bousculez le plus en Java est probablement NullPointerExceptions. La sécurité nulle est une fonctionnalité qui a été intégrée dans le langage Kotlin et qui est si implicite que vous n’avez généralement pas à vous soucier. La documentation officielle déclare que les seules causes possibles de NullPointerException sont:

• Un appel explicite à lancer !!.
• Utilisation de lateinit opérateur (que j'expliquerai plus tard).
• Code Java externe.
• Si le UninitializedPropertyAccessException propriété est accessible dans le constructeur avant son initialisation, un non-null sera jeté.

Par défaut, toutes les variables et propriétés de Kotlin sont considérées null (impossible de contenir une valeur null) s'ils ne sont pas explicitement déclarés comme nullables. Comme déjà mentionné, pour définir une variable pour accepter un val number: Int? = null valeur, un point d'interrogation doit être ajouté après le type. Par exemple:

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

Cependant, notez que le code suivant ne sera pas compilé:

null

C'est parce que le compilateur exécute null chèques. Pour compiler, a val number: Int? = null if(number != null) { number.toString(); } le chèque doit être ajouté:

number

Ce code sera compilé avec succès. Ce que Kotlin fait en arrière-plan, dans ce cas, c'est que nun-null devient Int (Int? au lieu de null) à l'intérieur du bloc if.

Le ?. la vérification peut être simplifiée en utilisant opérateur d'appel sécurisé (val number: Int? = null number?.toString() ):

null

La deuxième ligne ne sera exécutée que si le numéro n'est pas ?:. Vous pouvez même utiliser le célèbre Opérateur Elvis (val number Int? = null val stringNumber = number?.toString() ?: 'Number is null' ):

?:

Si l'expression à gauche de null n'est pas throw, il est évalué et renvoyé. Sinon, le résultat de l'expression de droite est renvoyé. Une autre chose intéressante est que vous pouvez utiliser return ou fun sendMailToUser(user: User) { val email = user?.email ?: throw new IllegalArgumentException('User email is null') //... } sur le côté droit de l'opérateur Elvis car ce sont des expressions dans Kotlin. Par exemple:

NullPointerException

La !! Opérateur

Si vous voulez un !! lancé de la même manière qu'en Java, vous pouvez le faire avec NullPointerException opérateur. Le code suivant lancera un val number: Int? = null number!!.toString() :

as

Fonderie

Casting effectué en utilisant un val x: String = y as String mot-clé:

ClassCastException

Ceci est considéré comme un casting «non sûr», car il lancera null si le cast n'est pas possible, comme le fait Java. Il existe un opérateur de transtypage «sûr» qui renvoie le val x: String = y as? String valeur au lieu de lever une exception:

null

Pour plus de détails sur la diffusion, consultez la Type et moulages section de la documentation officielle, et pour plus de détails sur lateinit vérifier la sécurité Null-Safety section.

lateinit Propriétés

Il existe un cas dans lequel l'utilisation de NullPointerException properties peut provoquer une exception similaire à class InitTest { lateinit var s: String; init { val len = this.s.length } } . Considérez la classe suivante:

TestClass

Ce code se compilera sans avertissement. Cependant, dès qu'une instance de UninitializedPropertyAccessException est créé, un s sera levé car la propriété with() est accessible avant d'être initialisé.

Caractéristique n ° 6: Fonction with()

Fonction with(helloWorldTextView) { text = 'Hello World!' visibility = View.VISIBLE } est utile et est fourni avec la bibliothèque standard Kotlin. Il peut être utilisé pour enregistrer un peu de frappe si vous devez accéder à de nombreuses propriétés d'un objet. Par exemple:

times(argument)

Il reçoit un objet et une fonction d'extension comme paramètres. Le bloc de code (entre accolades) est une expression lambda pour la fonction d'extension de l'objet spécifié comme premier paramètre.

Caractéristique n ° 7: surcharge de l'opérateur

Avec Kotlin, des implémentations personnalisées peuvent être fournies pour un ensemble prédéfini d'opérateurs. Pour implémenter un opérateur, une fonction membre ou une fonction d'extension avec le nom donné doit être fournie.

quel site propose un tuto pour apprendre la programmation c

Par exemple, pour implémenter l'opérateur de multiplication, une fonction membre ou une fonction d'extension, avec le nom operator fun String.times(b: Int): String { val buffer = StringBuffer() for (i in 1..b) { buffer.append(this) } return buffer.toString() } , doit être fournie:

*

L'exemple ci-dessus montre une implémentation de binaire String opérateur sur le newString. Par exemple, l'expression suivante attribuera la valeur «TestTestTestTest» à un val newString = 'Test' * 4 variable:

==

Puisque les fonctions d'extension peuvent être utilisées, cela signifie que le comportement par défaut des opérateurs pour tous les objets peut être modifié. Il s'agit d'une arme à double tranchant et doit être utilisée avec prudence. Pour obtenir la liste des noms de fonction de tous les opérateurs qui peuvent être surchargés, vérifiez le documentation officielle .

Une autre grande différence par rapport à Java est != et == les opérateurs. Opérateur a?.equals(b) ?: b === null Se traduit par:

!=

Tandis que l'opérateur !(a?.equals(b) ?: Se traduit par:

==

Ce que cela signifie, c'est que l'utilisation de equals() ne fait pas de contrôle d’identité comme en Java (comparez si les instances d’un objet sont identiques), mais se comporte de la même manière que null méthode avec === chèques.

Pour effectuer un contrôle d'identité, les opérateurs !== et class SomeClass { var p: String by Delegate() } doit être utilisé à Kotlin.

Fonctionnalité n ° 8: propriétés déléguées

Certaines propriétés partagent certains comportements communs. Par exemple:

• Propriétés à initialisation différée qui sont initialisées lors du premier accès.
• Propriétés qui implémentent Observable dans le modèle Observer.
• Propriétés qui sont stockées dans une carte à la place en tant que champs séparés.

Pour faciliter la mise en œuvre de cas comme celui-ci, Kotlin prend en charge Propriétés déléguées :

p

Cela signifie que les fonctions getter et setter pour la propriété Delegate sont gérées par une instance d'une autre classe, String.

Un exemple de délégué pour le 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.'') } } propriété:

var

L'exemple ci-dessus imprime un message lorsqu'une propriété est attribuée ou lue.

Les délégués peuvent être créés pour les propriétés mutables (val) et en lecture seule (getValue).

Pour une propriété en lecture seule, KProperty doit être mise en œuvre. Il faut deux paramètres (tirés du documentation officielle ):

• récepteur - doit être le même ou un supertype du propriétaire de la propriété (pour les propriétés d'extension, c'est le type en cours d'extension).
• métadonnées - doivent être de type setValue ou son supertype.

Cette fonction doit renvoyer le même type que la propriété ou son sous-type.

Pour une propriété mutable, un délégué doit fournir en plus une fonction nommée getValue() qui prend les paramètres suivants:

• récepteur - identique à getValue().
• métadonnées - comme pour getValue().
• nouvelle valeur - doit être du même type qu'une propriété ou son supertype.

Il existe quelques délégués standard fournis avec Kotlin qui couvrent les situations les plus courantes:

• Paresseux
• Observable
• Opposable

Paresseux

Lazy est un délégué standard qui prend une expression lambda comme paramètre. L'expression lambda passée est exécutée la première fois lazy(LazyThreadSafetyMode.NONE) { … } méthode est appelée.

Par défaut, l'évaluation des propriétés différées est synchronisée. Si vous n'êtes pas concerné par le multi-threading, vous pouvez utiliser Delegates.observable() pour obtenir des performances supplémentaires.

Observable

Le setValue() est pour les propriétés qui doivent se comporter comme des observables dans le modèle Observer. Il accepte deux paramètres, la valeur initiale et une fonction qui a trois arguments (propriété, ancienne valeur et nouvelle valeur).

L'expression lambda donnée sera exécutée à chaque fois class User { var email: String by Delegates.observable('') { prop, old, new -> //handle the change from old to new value } } La méthode est appelée:

Delegates.observable()

Opposable

Ce délégué standard est un type spécial d'Observable qui vous permet de décider si une nouvelle valeur affectée à une propriété sera stockée ou non. Il peut être utilisé pour vérifier certaines conditions avant d'attribuer une valeur. Comme pour true, il accepte deux paramètres: la valeur initiale et une fonction.

La différence est que la fonction renvoie une valeur booléenne. S'il renvoie var positiveNumber = Delegates.vetoable(0) { d, old, new -> new >= 0 } , la nouvelle valeur affectée à la propriété sera stockée ou supprimée.

class User(val map: Map) { val name: String by map val age: Int by map }

L'exemple donné ne stockera que les nombres positifs affectés à la propriété.

Pour plus de détails, consultez la documentation officielle .

Fonctionnalité n ° 9: mappage d'un objet sur une carte

Un cas d'utilisation courant consiste à stocker les valeurs des propriétés dans une carte. Cela se produit souvent dans les applications qui fonctionnent avec des API RESTful et analysent les objets JSON. Dans ce cas, une instance de carte peut être utilisée comme délégué pour une propriété déléguée. Un exemple du documentation officielle :

User

Dans cet exemple, val user = User(mapOf( 'name' to 'John Doe', 'age' to 25 )) a un constructeur principal qui prend une carte. Les deux propriétés prendront les valeurs de la carte qui sont mappées sous des clés égales aux noms de propriété:

MutableMap

La propriété name de la nouvelle instance utilisateur se verra attribuer la valeur «John Doe» et la propriété age la valeur 25.

Cela fonctionne pour les propriétés var en combinaison avec class MutableUser(val map: MutableMap) { var name: String by map var age: Int by map } ainsi que:

any

Fonction n ° 10: Collections et opérations fonctionnelles

Avec la prise en charge des lambdas dans Kotlin, les collections peuvent être exploitées à un nouveau niveau.

Tout d'abord, Kotlin fait la distinction entre les collections mutables et immuables. Par exemple, il existe deux versions de Itérable interface:

• Itérable
• MutableIterable

C'est la même chose pour Collection , liste , Ensemble et Carte les interfaces.

Par exemple, ceci true l'opération renvoie val list = listOf(1, 2, 3, 4, 5, 6) assertTrue(list.any { it % 2 == 0 }) si au moins un élément correspond au prédicat donné:

.apk

Pour une liste complète des opérations fonctionnelles pouvant être effectuées sur les collections, cochez cette case article de blog .

Conclusion

Nous venons de gratter la surface de ce que propose Kotlin. Pour ceux qui souhaitent en savoir plus et en savoir plus, consultez:

• Articles de blog et livre d'Antonio Leiva sur Kotlin .
• Documentation officielle et tutoriels de JetBrains.

Pour résumer, Kotlin vous offre la possibilité de gagner du temps lors de l'écriture native Android applications en utilisant une syntaxe intuitive et concise. C'est encore un jeune langage de programmation, mais à mon avis, il est maintenant suffisamment stable pour être utilisé pour créer des applications de production.

Les avantages de l'utilisation de Kotlin:

• La prise en charge par Android Studio est transparente et excellente.
• Il est facile de convertir un projet Java existant en Kotlin.
• Le code Java et Kotlin peut coexister dans le même projet.
• Il n'y a pas de surcharge de vitesse dans l'application.

Les inconvénients:

• Kotlin ajoutera ses bibliothèques au .apk généré, donc le

  |_+_|

  final | la taille sera d'environ 300 Ko plus grande.
• En cas d'abus, la surcharge de l'opérateur peut conduire à un code illisible.
• L'IDE et la saisie semi-automatique se comportent un peu plus lentement lorsque vous travaillez avec Kotlin qu'avec des projets Java Android purs.
• Les temps de compilation peuvent être un peu plus longs.