Kotlin ist bequem! Aber jetzt muss ich auch Java verwenden. Wie machst du das mit Kotlin? Also habe ich einen Spickzettel gemacht. Kommt mit Code, der sofort ausgeführt werden kann.
Art | Bitbreite | Art | Beispiel |
---|---|---|---|
Double | 64 | Gleitkomma | 12345.6 |
Float | 32 | Gleitkomma | 12345.6f |
Long | 64 | ganze Zahl | 123456L 999_99_9999L 0xFF_EC_DE_5E |
Int | 32 | ganze Zahl | 123456 0xFF_FF |
Short | 16 | ganze Zahl | 32767 0x0F |
Byte | 8 | ganze Zahl | 127 0b1010 |
String | - | String | "Hello, world!\n" |
Variable var
var a: Float
a = 12345.6f
Konstanter Wert
val a: Int = 10000
val b = 10_000L //Durch Unterstrich getrennt, damit die Ziffern besser sichtbar sind
Deklaration und Initialisierung müssen nicht gleichzeitig erfolgen.
val c: Double
c = 12345.6
if(true)
println("Hello")
if(false){
println("Hello")
} else if(true) {
println("Kotlin")
} else {
println("World!")
}
Da es sich um einen Ausdruck handelt, kann das Ergebnis zugewiesen werden. Die zuletzt ausgewertete Formel wird zurückgegeben.
val max = if (a > b) {
print("a is greater than b")
a
} else {
print("a is less than b")
b
}
Online ausführen (https://try.kotlinlang.org/#/UserProjects/6v4vmotcoemh93ckflpilmpct3/riuqp0d3kodcv08vq510inkc9p)
when (a) {
1 -> println("a == 1")
2,3 -> println("a == 2 or a == 3")
else -> {
println("otherwise")
}
}
Geben Sie den Bereich mit in an.
when (a) {
in 1..10 -> println("a is in the range")
!in 10..20 -> println("a is outside the range")
else -> println("otherwise")
}
for (a in 1..10) println(a)
for (a in 'Z' downTo 'A') print(a)
Sammlung
val array = arrayOf(297456, 119243,9,30)
for (a in array) {
println(a)
}
Wenn Sie einen Index verwenden möchten
val array = arrayOf(297456, 119243,9,30)
for (i in array.indices) {
println(array[i])
}
Gleich wie Java.
var x = 10
while (x > 0) {
println(x--)
}
do-while
do{
println("i = " + i--)
}while(i > 4)
Online ausführen (https://try.kotlinlang.org/#/UserProjects/6v4vmotcoemh93ckflpilmpct3/pdsmvtodipq00qvmhk75rbb9me)
Konvertieren Sie eine Zeichenfolge in eine Zahl
val intVal: Int = str.toInt()
val intValOrNull: Int? = str.toIntOrNull()
val doubleVal = str.toDouble()
Von jedem Typ zu einer Zeichenkette
val intStr = num.toString()
Casting-Zahlen (zB Int to Long-Konvertierung)
val long= int.toLong()
Gleich wie Java
Anwendungsbeispiel | Bedeutung | Anwendungsbeispiel | Bedeutung |
---|---|---|---|
x + y | Hinzufügen | x - y | Subtrahieren |
x * y | Multiplizieren | x / y | Teilung |
x % y | Überschuss | ||
++x / x++ | Zuwachs | --y / y-- | Dekrement |
Gleich wie Java
a && b (and) a || b (or) !a (not)
val multiline = """
for (c in "foo"){
print(c)
}
"""
val withTrim = """
|for (c in "foo"){
| print(c)
|}
""".trimMargin()
val str = "Hello Kotlin!"
val templete = " $str is ${str.length} characters."
// >Hello Kotlin! is 13 characters.
Wenn Sie $ so ausgeben möchten, wie es ist
val price = 200
val multiline = """
|This is ${'$'}$price.
""".trimMargin()
Fast das gleiche wie Java, aber "==" entspricht Java gleich. Der Objektvergleich ist in Kotlin "===".
Anwendungsbeispiel | Bedeutung | Anwendungsbeispiel | Bedeutung |
---|---|---|---|
x < y | x ist klein | x <= y | x ist klein oder gleich |
x > y | x ist groß | x >= y | x ist größer oder gleich |
x == y | das Gleiche | x != y | anders |
x === y | Gleiches Objekt | x !== y | Objekte sind unterschiedlich |
Beispiel | Bedeutung |
---|---|
s.length | s Länge |
s.count() | s Länge |
s[i] | i-te Charakter |
s.substring(start..end) | Teilzeichenfolge von Anfang bis Ende |
s.substring(start,end) | Anfang bis Ende-Teilstring bis zu 1 |
s.toUpperCase() | Konvertierung in Großbuchstaben |
s.toLowerCase() | Kleinbuchstabenumrechnung |
s.indexOf('x') | 'x'Index wo |
s.replace(old,new) | String-Ersatz |
s.replaceFirst(old,new) | Ersatz der ersten gefundenen Zeichenfolge |
s.split(regex) | Zu teilen |
s.trim() | Entfernen Sie den vorderen und hinteren Leerraum |
s.startsWith(prefix) | Gibt true zurück, wenn die Zeichenfolge mit frefix beginnt |
s.endsWith(suffix) | Gibt true zurück, wenn die Zeichenfolge mit dem Suffix endet |
List
Schreibgeschützte Liste
val items = listOf(1, 2, 3)
println(items)
Änderbare Liste
val numbers: MutableList<Int> = mutableListOf(1, 2, 3)
numbers.add(4)
Set
Schreibgeschütztes Set
var strings: Set<String> = setOf("A","B","C")
Wechselbares Set
var stringSet: MutableSet<String> = mutableSetOf("x","y","z")
stringSet.add("a")
stringSet.filter { it != "x"}
Map
Schreibgeschützte Karte
val fruits = mapOf("apple" to 1, "orange" to 2, "banana" to 3)
Veränderbare Karte
val readWriteMap = mutableMapOf("apple" to 1, "orange" to 2, "banana" to 3)
readWriteMap.put("melon",4)
Kotlin-Funktionen werden mit dem Schlüsselwort fun definiert
fun times(a: Int, b: Int): Int {
return a * b
}
Funktionsausführung
val result = times(2,5)
Wenn der Funktionskörper aus einem Ausdruck besteht, kann die mittlere Klammer weggelassen und der Ausdruck nach = geschrieben werden. Der Rückgabewert kann durch Inferenz weggelassen werden.
fun times(a: Int, b: Int) = a * b
Für das Argument kann ein Standardwert angegeben werden. Sie können den Namen des Arguments angeben, wenn Sie die Funktion aufrufen.
val result = makeString(base = "world ", concl = "of Kotlin!")
open class Parent{
open fun show() = println("This is Parent")
}
class Child:Parent(){
override fun show() = println("This is Child")
}
Initializer: Der Initialisierungscode verwendet den Init-Block
class Person(val name: String, val isMan:Boolean, var favorite:String ){
init {
val s = if(isMan) "He" else "She"
favorite = "$s liles $favorite"
}
}
Durch die Definition als Datenklasse werden gleich, hashCode, toString und copy automatisch generiert.
data class Dog(val name: String)
Eine Funktion, die einer anonymen Klasse in Java entspricht. Objekt: Name der Vererbungsklasse (Schnittstelle) {Implementierung}
view.setOnClickListener(object: View.OnClickListener {
override fun onClick(v: View?) {
view.text = "clicked"
}
})
{Variable:Schimmel->wird bearbeitet}
Lambda-Ausdrücke können in Variablen gespeichert werden
val minus = {x: Int, y: Int -> x - y }
Wenn der Lambda-Ausdruck ein Argument hat, kann das Argument weggelassen und das implizite Argument verwendet werden.
val double:(Int)->Int = {it * 2}
Verwenden Sie ClassName :: class.java oder instance :: class.java, um java.lang.Class abzurufen
val clazz = Activity::class.java
val clazzz = this::class.java
Recommended Posts