Kotlin
Expressions idiomatiques

Création de DTO (POJO / POCO)

Les classes de données dans kotlin sont des classes créées pour ne rien faire mais contenir des données. Ces classes sont marquées comme des data :

data class User(var firstname: String, var lastname: String, var age: Int)

Le code ci-dessus crée une classe User avec les éléments suivants générés automatiquement:

• Getters et Setters pour toutes les propriétés (seulement pour les val s)
• equals()
• hashcode()
• toString()
• copy()
• componentN() (où N est la propriété correspondante dans l'ordre de déclaration)

Tout comme avec une fonction, les valeurs par défaut peuvent également être spécifiées:

data class User(var firstname: String = "Joe", var lastname: String = "Bloggs", var age: Int = 20)

Plus de détails peuvent être trouvés ici Data Classes .

Filtrer une liste

val list = listOf(1,2,3,4,5,6)

//filter out even numbers

val even = list.filter { it % 2 == 0 }

println(even) //returns [2,4]

Déléguer à une classe sans la fournir dans le constructeur public

Supposons que vous souhaitiez déléguer à une classe mais que vous ne souhaitez pas fournir la classe déléguée dans le paramètre constructeur. Au lieu de cela, vous voulez le construire en privé, en ignorant l'appelant du constructeur. Au début, cela peut sembler impossible car la délégation de classe permet de déléguer uniquement aux paramètres du constructeur. Cependant, il y a un moyen de le faire, comme indiqué dans cette réponse :

class MyTable private constructor(table: Table<Int, Int, Int>) : Table<Int, Int, Int> by table {

    constructor() : this(TreeBasedTable.create()) // or a different type of table if desired

}

Avec ceci, vous pouvez simplement appeler le constructeur de MyTable comme ceci: MyTable() . La Table<Int, Int, Int> à laquelle les délégués MyTable seront créés en privé. L'appelant constructeur n'en sait rien.

Cet exemple est basé sur cette question SO .

Serializable et serialVersionUid dans Kotlin

Pour créer le serialVersionUID d'une classe dans Kotlin, vous disposez de quelques options, toutes impliquant l'ajout d'un membre à l'objet compagnon de la classe.

Le code d'octet le plus concis provient d'une valeur private const val qui deviendra une variable statique privée sur la classe contenant, dans ce cas MySpecialCase :

class MySpecialCase : Serializable {
    companion object {
        private const val serialVersionUID: Long = 123
    }
}

Vous pouvez également utiliser ces formulaires, chacun avec un effet secondaire d'avoir des méthodes de lecture / définition qui ne sont pas nécessaires pour la sérialisation ...

class MySpecialCase : Serializable {
    companion object {
        private val serialVersionUID: Long = 123
    }
}

Cela crée le champ statique mais crée également un getter getSerialVersionUID sur l'objet compagnon qui n'est pas nécessaire.

class MySpecialCase : Serializable {
    companion object {
        @JvmStatic private val serialVersionUID: Long = 123
    }
}  

Cela crée le champ statique mais crée également un getter statique ainsi que getSerialVersionUID sur la classe contenant MySpecialCase qui est inutile.

Mais tout fonctionne comme une méthode pour ajouter serialVersionUID à une classe Serializable .

Méthodes courant à Kotlin

Les méthodes courantes dans Kotlin peuvent être les mêmes que Java:

fun doSomething() {
   someOtherAction()
   return this
}

Mais vous pouvez également les rendre plus fonctionnels en créant une fonction d’extension telle que:

fun <T: Any> T.fluently(func: ()->Unit): T {
    func()
    return this
}

Ce qui permet alors des fonctions plus évidentes:

fun doSomething() {
   return fluently { someOtherAction() }
}

Utiliser let ou simplifier le travail avec des objets nullables

let dans Kotlin crée une liaison locale à partir de l'objet sur lequel il a été appelé. Exemple:

val str = "foo"
str.let {
    println(it) // it
}  

Cela affichera "foo" et renverra Unit .

La différence entre let et also est que vous pouvez retourner n'importe quelle valeur d'un bloc let . also autre part, toujours reutrn Unit .

Maintenant, pourquoi c'est utile, vous demandez? Parce que si vous appelez une méthode qui peut renvoyer null et que vous souhaitez exécuter du code uniquement lorsque cette valeur de retour n'est pas null vous pouvez utiliser let ou also comme ceci:

val str: String? = someFun()
str?.let {
    println(it)
}

Ce morceau de code exécutera uniquement le bloc let lorsque str n'est pas null . Notez l'opérateur de sécurité null ( ? ).

Utiliser apply pour initialiser des objets ou pour réaliser un chaînage de méthode

La documentation de apply indique ce qui suit:

appelle le bloc fonction spécifié avec this valeur comme récepteur et renvoie this valeur.

Bien que le kdoc ne soit pas très utile, l’ apply est en effet une fonction utile. Dans les termes de profane, apply définit une portée dans laquelle this est lié à l'objet que vous avez appelé apply . Cela vous permet d'économiser du code lorsque vous devez appeler plusieurs méthodes sur un objet que vous renverrez ensuite. Exemple:

File(dir).apply { mkdirs() }

C'est la même chose que d'écrire ceci:

fun makeDir(String path): File {
    val result = new File(path)
    result.mkdirs()
    return result
}