Kotlin est pratique! Mais maintenant, je dois aussi utiliser Java. Comment fais-tu ça avec Kotlin? Alors j'ai fait une feuille de triche. Livré avec du code qui peut être exécuté immédiatement.
type | Largeur de bits | type | Exemple |
---|---|---|---|
Double | 64 | Point flottant | 12345.6 |
Float | 32 | Point flottant | 12345.6f |
Long | 64 | entier | 123456L 999_99_9999L 0xFF_EC_DE_5E |
Int | 32 | entier | 123456 0xFF_FF |
Short | 16 | entier | 32767 0x0F |
Byte | 8 | entier | 127 0b1010 |
String | - | Chaîne | "Hello, world!\n" |
Var variable
var a: Float
a = 12345.6f
Val constant
val a: Int = 10000
val b = 10_000L //Séparé par un trait de soulignement pour rendre les chiffres plus faciles à voir
La déclaration et l'initialisation ne doivent pas être simultanées.
val c: Double
c = 12345.6
if(true)
println("Hello")
if(false){
println("Hello")
} else if(true) {
println("Kotlin")
} else {
println("World!")
}
Puisqu'il s'agit d'une expression, le résultat peut être attribué. La dernière formule évaluée est renvoyée.
val max = if (a > b) {
print("a is greater than b")
a
} else {
print("a is less than b")
b
}
when (a) {
1 -> println("a == 1")
2,3 -> println("a == 2 or a == 3")
else -> {
println("otherwise")
}
}
Spécifiez la plage avec in.
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)
collection
val array = arrayOf(297456, 119243,9,30)
for (a in array) {
println(a)
}
Si vous souhaitez utiliser un index
val array = arrayOf(297456, 119243,9,30)
for (i in array.indices) {
println(array[i])
}
Identique à Java.
var x = 10
while (x > 0) {
println(x--)
}
do-while
do{
println("i = " + i--)
}while(i > 4)
Exécutez en ligne (https://try.kotlinlang.org/#/UserProjects/6v4vmotcoemh93ckflpilmpct3/pdsmvtodipq00qvmhk75rbb9me)
Convertir une chaîne en nombre
val intVal: Int = str.toInt()
val intValOrNull: Int? = str.toIntOrNull()
val doubleVal = str.toDouble()
De chaque type à une chaîne de caractères
val intStr = num.toString()
Numéros de diffusion (par exemple, conversion Int en Long)
val long= int.toLong()
Identique à Java
Exemple d'utilisation | sens | Exemple d'utilisation | sens |
---|---|---|---|
x + y | Ajouter | x - y | Soustraire |
x * y | Multiplier | x / y | division |
x % y | Surplus | ||
++x / x++ | Incrément | --y / y-- | Décrémenter |
Identique à 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.
Lorsque vous souhaitez afficher $ tel quel
val price = 200
val multiline = """
|This is ${'$'}$price.
""".trimMargin()
Presque identique à Java, mais "==" équivaut à Java est égal à. La comparaison d'objets est "===" dans Kotlin.
Exemple d'utilisation | sens | Exemple d'utilisation | sens |
---|---|---|---|
x < y | x est petit | x <= y | x est petit ou identique |
x > y | x est grand | x >= y | x est supérieur ou identique |
x == y | le même | x != y | différent |
x === y | Même objet | x !== y | Les objets sont différents |
Exemple | sens |
---|---|
s.length | s longueur |
s.count() | s longueur |
s[i] | i-ème caractère |
s.substring(start..end) | Sous-chaîne du début à la fin |
s.substring(start,end) | commencer à finir-Sous-chaîne jusqu'à 1 |
s.toUpperCase() | Conversion en majuscules |
s.toLowerCase() | Conversion en minuscules |
s.indexOf('x') | 'x'Index où |
s.replace(old,new) | Remplacement de la chaîne |
s.replaceFirst(old,new) | Remplacement de la première chaîne trouvée |
s.split(regex) | Diviser |
s.trim() | Supprimer les espaces blancs à l'avant et à l'arrière |
s.startsWith(prefix) | Renvoie true si la chaîne commence par frefix |
s.endsWith(suffix) | Renvoie true si la chaîne se termine par le suffixe |
List
Liste en lecture seule
val items = listOf(1, 2, 3)
println(items)
Liste modifiable
val numbers: MutableList<Int> = mutableListOf(1, 2, 3)
numbers.add(4)
Set
Ensemble en lecture seule
var strings: Set<String> = setOf("A","B","C")
Ensemble modifiable
var stringSet: MutableSet<String> = mutableSetOf("x","y","z")
stringSet.add("a")
stringSet.filter { it != "x"}
Map
Carte en lecture seule
val fruits = mapOf("apple" to 1, "orange" to 2, "banana" to 3)
Carte modifiable
val readWriteMap = mutableMapOf("apple" to 1, "orange" to 2, "banana" to 3)
readWriteMap.put("melon",4)
Les fonctions Kotlin sont définies avec le mot-clé fun
fun times(a: Int, b: Int): Int {
return a * b
}
Exécution de la fonction
val result = times(2,5)
Exécutez en ligne (https://try.kotlinlang.org/#/UserProjects/7ipoghpd4rm475oncc8tdnmj8b/rvavpm8nfm0drgrgv5p37fd0fe)
Si le corps de la fonction se compose d'une seule expression, le crochet du milieu peut être omis et l'expression peut être écrite après =. La valeur de retour peut être omise par inférence.
fun times(a: Int, b: Int) = a * b
Une valeur par défaut peut être spécifiée pour l'argument. Vous pouvez spécifier le nom de l'argument lors de l'appel de la fonction.
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")
}
Initialiseur: le code d'initialisation utilise le bloc d'initialisation
class Person(val name: String, val isMan:Boolean, var favorite:String ){
init {
val s = if(isMan) "He" else "She"
favorite = "$s liles $favorite"
}
}
En le définissant comme classe de données, equals, hashCode, toString et copy sont automatiquement générés.
data class Dog(val name: String)
Une fonction qui correspond à une classe anonyme en Java. objet: nom de la classe d'héritage (interface) {implémentation}
view.setOnClickListener(object: View.OnClickListener {
override fun onClick(v: View?) {
view.text = "clicked"
}
})
{variable:Moule->En traitement}
Les expressions Lambda peuvent être stockées dans des variables
val minus = {x: Int, y: Int -> x - y }
Si l'expression lambda a un argument, l'argument peut être omis et l'argument implicite peut être utilisé.
val double:(Int)->Int = {it * 2}
Utilisez ClassName :: class.java ou instance :: class.java pour obtenir java.lang.Class
val clazz = Activity::class.java
val clazzz = this::class.java
Recommended Posts