Kotlin
Modismos

Creación de DTO (POJOs / POCOs)

Las clases de datos en kotlin son clases creadas para hacer nada más que mantener datos. Tales clases están marcadas como data :

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

El código anterior crea una clase de User con lo siguiente generado automáticamente:

• Getters y Setters para todas las propiedades (getters solo para val s)
• equals()
• hashcode()
• toString()
• copy()
• componentN() (donde N es la propiedad correspondiente en orden de declaración)

Al igual que con una función, los valores predeterminados también se pueden especificar:

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

Más detalles se pueden encontrar aquí Clases de datos .

Filtrando una lista

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]

Delegado a una clase sin aportarlo en el constructor público.

Suponga que desea delegar en una clase pero no desea proporcionar la clase delegada a en el parámetro constructor. En su lugar, desea construirlo de forma privada, haciendo que el constructor que llama no lo sepa. Al principio, esto puede parecer imposible porque la delegación de clase permite delegar solo a los parámetros del constructor. Sin embargo, hay una manera de hacerlo, como se indica en esta respuesta :

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

}

Con esto, puedes llamar al constructor de MyTable así: MyTable() . La Table<Int, Int, Int> en la que se crearán los delegados de MyTable forma privada. El que llama al constructor no sabe nada al respecto.

Este ejemplo se basa en esta pregunta SO .

Serializable y serialVersionUid en Kotlin

Para crear el serialVersionUID para una clase en Kotlin, tiene algunas opciones, todas relacionadas con la adición de un miembro al objeto complementario de la clase.

El bytecode más conciso proviene de una private const val que se convertirá en una variable estática privada en la clase contenedora, en este caso MySpecialCase :

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

También puede usar estos formularios, cada uno con el efecto secundario de tener métodos de obtención / establecimiento que no son necesarios para la serialización ...

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

Esto crea el campo estático, pero también crea un getter y getSerialVersionUID en el objeto complementario que no es necesario.

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

Esto crea el campo estático, pero también crea un getter estático y getSerialVersionUID en la clase que contiene MySpecialCase que no es necesario.

Pero todo funciona como un método para agregar el serialVersionUID a una clase Serializable .

Métodos fluidos en Kotlin

Los métodos fluidos en Kotlin pueden ser los mismos que en Java:

fun doSomething() {
   someOtherAction()
   return this
}

Pero también puede hacer que sean más funcionales creando una función de extensión como:

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

Lo que entonces permite funciones más obviamente obvias:

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

Utilice let o también para simplificar el trabajo con objetos anulables.

let Kotlin cree un enlace local desde el objeto al que fue llamado. Ejemplo:

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

Esto imprimirá "foo" y devolverá la Unit .

La diferencia entre let y also es que puede devolver cualquier valor de un bloque let . also en la otra parte siempre reutrn la Unit .

Ahora, ¿por qué esto es útil, preguntas? Porque si llama a un método que puede devolver null y desea ejecutar algún código solo cuando el valor de retorno no es null , puede usar let o also esto:

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

Este fragmento de código solo ejecutará el bloque let cuando str no sea null . Tenga en cuenta el operador de seguridad null ( ? ).

Utilice aplicar para inicializar objetos o para lograr el encadenamiento de métodos.

La documentación de apply dice lo siguiente:

llama al bloque de funciones especificado con this valor como su receptor y devuelve this valor.

Mientras que el kdoc no es tan útil apply es de hecho una función útil. En términos sencillos, apply establece un alcance en el que this está vinculado al objeto al que llamó apply . Esto le permite ahorrar algo de código cuando necesita llamar a múltiples métodos en un objeto que luego devolverá. Ejemplo:

File(dir).apply { mkdirs() }

Esto es lo mismo que escribir esto:

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