Kotlin
idiom

Skapa DTO: er (POJO / POCO)

Dataklasser i Kotlin är klasser som skapas för att göra annat än att hålla data. Sådana klasser är markerade som data :

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

Koden ovan skapar en User klass med följande automatiskt:

• Getters and Setters för alla fastigheter (getters endast för val )
• equals()
• hashcode()
• toString()
• copy()
• componentN() (där N är motsvarande egenskap i deklarationsordning)

Precis som med en funktion kan standardvärden också anges:

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

Mer information finns här Dataklasser .

Filtrera en 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]

Delegera till en klass utan att tillhandahålla den i den offentliga konstruktören

Antag att du vill delegera till en klass men du vill inte ge den delegerade till klassen i konstruktörsparametern. Istället vill du konstruera det privat, vilket gör konstruktörens uppringare omedvetna om det. Till att börja med kan detta verka omöjligt eftersom klassdelegering tillåter att delegera endast till konstruktörsparametrar. Det finns emellertid ett sätt att göra det, vilket ges i detta svar :

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

}

Med detta kan du bara ringa konstruktören för MyTable så: MyTable() . Table<Int, Int, Int> till vilken MyTable delegater skapas privat. Konstruktörspresentant vet ingenting om det.

Detta exempel är baserat på denna SO-fråga .

Serialiserbar och serieVersionUid i Kotlin

För att skapa serialVersionUID för en klass i Kotlin har du några alternativ som alla involverar att lägga till en medlem i klassens följeslagareobjekt.

Den mest kortfattade bytekoden kommer från en private const val som kommer att bli en privat statisk variabel på den innehållande klassen, i detta fall MySpecialCase :

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

Du kan också använda dessa former, var och en med en bieffekt av att ha getter / setter-metoder som inte är nödvändiga för serialisering ...

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

Detta skapar det statiska fältet men skapar också en getter samt getSerialVersionUID på det följeslagna objektet som är onödigt.

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

Detta skapar det statiska fältet men skapar också en statisk getter samt getSerialVersionUID på den innehållande klassen MySpecialCase som är onödigt.

Men alla fungerar som en metod för att lägga till serialVersionUID i en klass som kan Serializable .

Flytande metoder i Kotlin

Flytande metoder i Kotlin kan vara samma som Java:

fun doSomething() {
   someOtherAction()
   return this
}

Men du kan också göra dem mer funktionella genom att skapa en tilläggsfunktion som:

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

Som sedan tillåter mer uppenbarligen flytande funktioner:

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

Använd låt eller också för att förenkla arbetet med nollbara objekt

let in Kotlin skapar en lokal bindning från det objekt som det kallades på. Exempel:

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

Detta kommer att skriva ut "foo" och returnerar Unit .

Skillnaden mellan let och also är att du kan returnera något värde från en let block. also å andra sidan kommer alltid att återgå Unit .

Nu varför detta är användbart, frågar du? För om du kallar en metod som kan returnera null och du bara vill köra en kod när det returneringsvärdet inte är null du använda let eller also gilla det här:

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

Denna bit kod kommer bara köra let blocket när str inte null . Observera null ( ? ).

Använd tillämpning för att initialisera objekt eller för att uppnå metodkedja

Dokumentationen för apply säger följande:

anropar det specificerade funktionsblocket med this värde som mottagare och returnerar this värde.

Även om kdoc inte är så användbar är apply verkligen en användbar funktion. I lekmannens villkor apply upprättar ett räckvidd där this är bundet till det objekt du ringde apply på. Detta gör att du kan skona viss kod när du behöver ringa flera metoder på ett objekt som du sedan kommer tillbaka senare. Exempel:

File(dir).apply { mkdirs() }

Detta är samma sak som att skriva detta:

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