Types de données de base de Kotlin

Les types numériques de base de Kotlin incluent Byte, Short, Int, Long, Float, Double, etc.

Contrairement à Java, les caractères ne sont pas un type numérique et constituent un type de données indépendant.

Types entiers

• Byte: 8 bits, plage de -128 à 127.
• Short: 16 bits, plage de -32,768 à 32,767.
• Int: 32 bits, plage de -2^31 à 2^31 - 1.
• Long: 64 bits, plage de -2^63 à 2^63 - 1.

Types à virgule flottante

• Float: 32 bits, simple précision, avec 6-7 chiffres significatifs.
• Double: 64 bits, double précision, avec 15-16 chiffres significatifs.

Type caractère

• Char: caractère Unicode de 16 bits.

Type booléen

• Boolean: possède deux valeurs :trueetfalse。

Type de chaîne

• String: une séquence de caractères.

Type Array

Kotlin fournit des types de tableau pour stocker des éléments du même type, par exemple :

• IntArray: stockeInt.
• DoubleArray: stockeDouble.
• Array<T>: tableau générique, peut stocker n'importe quel type.

Constantes littérales

Les éléments suivants sont des constantes littérales de tous les types :

• Décimal : 123
• Les entiers longs se terminent par un L majuscule : 123L
• L'hexadécimal commence par 0x : 0x0F
• Le binaire commence par 0b : 0b00001011
• Remarque : l'octal n'est pas pris en charge

Kotlin prend également en charge les valeurs à virgule flottante en notation traditionnelle :

• Notation par défaut des doubles :123.5, 123.5e10
• Les flottants utilisent le suffixe f ou F :123.5f

Vous pouvez utiliser des traits de soulignement pour rendre les constantes numériques plus lisibles :

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

Comparaison de deux nombres

En Kotlin, la comparaison de deux nombres peut utiliser les opérateurs de comparaison standard, notamment==、!=、<、>、<=et>=. Ces opérateurs peuvent comparer des types de données de base, tels queInt、Double、Floatetc.

fun main() {
    val a: Int = 5
    val b: Int = 10
    val c: Double = 5.0

    // 相等和不相等比较
    println("a == b: ${a == b}")   // 输出 false
    println("a != b: ${a != b}")   // 输出 true

    // 大小比较
    println("a < b: ${a < b}")     // 输出 true
    println("a > b: ${a > b}")     // 输出 false
    println("a <= b: ${a <= b}")   // 输出 true
    println("a >= b: ${a >= b}")   // 输出 false

    // 不同类型的比较
    println("a == c: ${a == c}")   // 输出 true，Kotlin 自动将 Int 转换为 Double 进行比较
    println("a < c: ${a < c}")     // 输出 false
    println("a > c: ${a > c}")     // 输出 false
}

1. Conversion de type: Kotlin effectue automatiquement une conversion de type lors de la comparaison de différents types de données. Par exemple, dans l'exemple ci-dessus,aOuiInttype, etcOuiDoubletype, Kotlin convertira automatiquementaàDoubletype pour la comparaison.

2. Égalité: Dans Kotlin,==opérateur est utilisé pour la comparaison d'égalité structurelle, c'est-à-dire la comparaison de valeurs, tandis que===opérateur est utilisé pour la comparaison d'égalité référentielle, c'est-à-dire si les objets sont la même instance. Lors de la comparaison de types de données de base, l'==opérateur est généralement utilisé.

fun main() {
    val x: Int = 1000
    val y: Int = 1000

    println("x == y: ${x == y}")   // 输出 true，值相等
    println("x === y: ${x === y}") // 输出 false，不同的实例

    val z: Int = x
    println("x === z: ${x === z}") // 输出 true，引用相同
}

Dans cet exemple,xetyvaleurs sont égales, mais ce sont des instances différentes, doncx === yrenvoiefalse. Maisxetzfont référence à la même instance, doncx === zrenvoietrue。

Conversion de type

En raison de représentations différentes, les types plus petits ne sont pas des sous-types de types plus grands, et les types plus petits ne peuvent pas être convertis implicitement en types plus grands. Cela signifie que nous ne pouvons pas affecter une valeur Byte à une variable Int sans conversion explicite.

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b // 错误

Nous pouvons plutôt utiliser sa méthode toInt().

val b: Byte = 1 // OK, 字面值是静态检测的
val i: Int = b.toInt() // OK

Chaque type de données possède les méthodes suivantes permettant de convertir vers d'autres types :

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

Dans certains cas, une conversion automatique de type est également possible, à condition que le type de données correct puisse être déduit du contexte et que les opérateurs mathématiques soient surchargés en conséquence. Par exemple, ce qui suit est correct :

val l = 1L + 3 // Long + Int => Long

Opérateurs bit à bit

Pour les types Int et Long, il existe également une série d'opérateurs bit à bit qui peuvent être utilisés, à savoir :

shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与
or(bits) – ou 
xor(bits) – 异或
inv() – 反向

Caractères

Contrairement à Java, Char en Kotlin ne peut pas être directement utilisé avec des nombres, et Char doit être placé entre guillemets simples'. Par exemple, les caractères ordinaires '0', 'a'.

fun check(c: Char) {
    if (c == 1) { // 错误：类型不兼容
        // ……
    }
}

Les littéraux de caractère sont placés entre guillemets simples : '1'. Les caractères spéciaux peuvent être échappés avec des barres obliques inverses. Les séquences d'échappement suivantes sont prises en charge : \t, \b, \n, \r, \', \", \\ et \$. Pour encoder d'autres caractères, utilisez la syntaxe de séquence d'échappement Unicode : '\uFF00'.

Nous pouvons convertir explicitement un caractère en un nombre Int :

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // 显式转换为数字
}

Lorsqu'une référence nullable est nécessaire, les nombres et les caractères sont encapsulés. Les opérations d'encapsulation ne préservent pas l'identité.

Boolean

Un booléen est représenté par le type Boolean, qui possède deux valeurs : true et false.

Si une référence nullable est nécessaire, les booléens seront encapsulés.

Les opérations booléennes intégrées comprennent :

|| – Short-circuit logical OR
&& – Short-circuit logical AND
! - Logical NOT

Tableaux

Les tableaux sont implémentés avec la classe Array et possèdent également une propriété size ainsi que des méthodes get et set. Comme [] surcharge les méthodes get et set, nous pouvons facilement obtenir ou définir la valeur à la position correspondante du tableau au moyen d'un indice.

Il existe deux façons de créer un tableau : l'une consiste à utiliser la fonction arrayOf(); l'autre consiste à utiliser des fonctions de fabrique. Comme illustré ci-dessous, nous avons créé deux tableaux de deux manières :

fun main(args: Array<String>) {
    //[1,2,3]
    val a = arrayOf(1, 2, 3)
    //[0,2,4]
    val b = Array(3, { i -> (i * 2) })

    //读取数组内容
    println(a[0])    // 输出结果：1
    println(b[1])    // 输出结果：2
}

Comme mentionné ci-dessus, l'opérateur [] représente l'appel des fonctions membres get() et set().

Remarque : Contrairement à Java, les tableaux en Kotlin sont invariants.

En plus de la classe Array, il existe également ByteArray, ShortArray et IntArray, qui représentent des tableaux de différents types, éliminant les opérations de boxing, et sont donc plus efficaces. Leur utilisation est identique à celle de Array :

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

Chaînes de caractères

Comme en Java, String est immuable. La syntaxe avec crochets [] permet d'obtenir facilement un caractère de la chaîne, et permet également de parcourir la chaîne avec une boucle for :

for (c in str) {
    println(c)
}

Kotlin prend en charge les chaînes entourées de trois guillemets """, ce qui permet les chaînes multilignes, par exemple :

fun main(args: Array<String>) {
    val text = """
    多行字符串
    多行字符串
    """
    println(text)   // 输出有一些前置空格
}

String peut utiliser la méthode trimMargin() pour supprimer les espaces superflus.

fun main(args: Array<String>) {
    val text = """
    |多行字符串
    |Example
    |多行字符串
    |Example
    """.trimMargin()
    println(text)    // 前置空格删除了
}

Par défaut, | est utilisé comme préfixe de limite, mais vous pouvez choisir un autre caractère et le passer en paramètre, par exemple trimMargin(">").

Modèles de chaînes

Les chaînes peuvent contenir des expressions de modèle, c'est-à-dire de petits fragments de code, qui sont évalués et dont les résultats sont fusionnés dans la chaîne. Les expressions de modèle commencent par un signe dollar ($) et consistent en un simple nom :

fun main(args: Array<String>) {
    val i = 10
    val s = "i = $i" // 求值结果为 "i = 10"
    println(s)
}

Ou des expressions arbitraires entre accolades :

fun main(args: Array<String>) {
    val s = "example"
    val str = "$s.length is ${s.length}" // 求值结果为 "example.length is 6"
    println(str)
}

Les modèles sont pris en charge à l'intérieur des chaînes brutes et des chaînes échappées. Si vous devez représenter le caractère $ littéral dans une chaîne brute (qui ne prend pas en charge l'échappement par barre oblique inverse), vous pouvez utiliser la syntaxe suivante :

fun main(args: Array<String>) {
    val price = """
    ${'$'}9.99
    """
    println(price)  // 求值结果为 $9.99
}