Modismos en Kotlin

Las clases de datos en Kotlin son clases creadas para hacer nada más que almacenar datos. Tales clases se marcan como datos:

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

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

• Getters y Setters para todas las propiedades (getters solo para vals )
• es igual()
• código hash()
• Enstringr()
• Copiar()
• componenteN() (donde N es la propiedad correspondiente en orden de declaración)

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

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

Filtrar 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]

Delegar a una clase sin proporcionarla en el constructor público

Suponga que desea delegar en una clase, pero no desea proporcionar la clase delegada en el parámetro del constructor. En cambio, desea construirlo de forma privada, haciendo que la persona que llama al constructor 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
{
  // or a different type of table if desired
  constructor() : this(TreeBasedTable.create()) 
}

Con esto, puede simplemente llamar al constructor de MyTable así: MyTable(). La tabla<Int, Int, Int> en la que se crearán de forma privada los delegados de MyTable. La persona 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 agregar un miembro al objeto complementario de la clase. El bytecode más conciso proviene de una const Val privada 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 getter/setter 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 getSerialVersionUID en el objeto complementario que es innecesario.

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

Esto crea el campo estático, pero también crea un captador estático y getSerialVersionUID en la clase contenedora MySpecialCase, que no es necesario. Pero todos funcionan como un método para agregar 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 hacerlos más funcionales creando una función de extensión como:

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

Lo que luego permite funciones más obviamente fluidas:

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

Use let o también para simplificar el trabajo con objetos anulables let en Kotlin crea un enlace local desde el objeto al que se invocó. Ejemplo:

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

Esto imprimirá “ foo ” y devolverá Unit .

• La diferencia entre let y also es que puedes devolver cualquier valor de un bloque let. también por otro lado siempre devolverá Unit .
• Ahora, ¿por qué esto es útil, te preguntarás? Porque si llama a un método que puede devolver un valor nulo y desea ejecutar algún código solo cuando ese valor de retorno no es nulo, puede usar let o también así:

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

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

Use apply para inicializar objetos o lograr el enstringmiento de métodos

La documentación de solicitud dice lo siguiente: 

llama al bloque de funciones especificado con este valor como su receptor y devuelve este valor. Si bien el kdoc no es tan útil, apply es una función útil. En términos sencillos, apply establece un alcance en el que esto está vinculado al objeto al que llamó apply . Esto le permite ahorrar algo de código cuando necesita llamar a varios métodos en un objeto que luego devolverá. 

Ejemplo:

Archivo(dir).aplicar { mkdirs() }

Esto es lo mismo que escribir esto:

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