Kotlin : Les Types de données

Kotlin est un langage à typage statique comme Java. C'est-à-dire que le type d'une variable est connu lors de la compilation. Par exemple
val taille : Int
val largeur = 15,20


Ici, le compilateur sait que taille est de type Int et que largeur est de type Double avant la compilation.
Les types intégrés dans Kotlin peuvent être classés comme suit :
Kotlin les data types


Le Type Nombre
Les nombres en Kotlin sont similaires à ceux de Java. Il existe 6 types intégrés représentant les nombres :
1. Octet :
fun main(args : Array<String>) {
    val gamme : Octet = 80
    println("$range")
    // Le code ci-dessous donne une erreur. Pourquoi ?
    // val gamme1 : Octet = 200
}

Sortie :
80


2. Short :
Le type de données Short peut avoir des valeurs comprises entre -32768 et 32767 (nombre entier de complément à deux signé de 16 bits).Il est utilisé à la place des autres types de données entières pour économiser de la mémoire s'il est certain que la valeur de la variable sera comprise entre [-32768, 32767].


fun main(args : Array<String>) {
    val température : Court = -11245
    println("$température")
}


Sortie :
-11245


3. Int :
Le type de données Int peut avoir des valeurs comprises entre -2^31 et 2^(31)-1 (entier à complément à deux signé 32 bits).
fun main(args : Array<String>) {
    val score : Int = 100000
    println("$score")
}

Sortie :
100000

Si vous attribuez un nombre entier compris entre -2^31 et 2^(31)-1 à une variable sans spécifier explicitement son type, la variable sera de type Int. Par exemple
fun main(args : Array<String>) {
   // score est de type Int
    val score = 10
    println("$score")
}

Si vous utilisez IntelliJ IDEA, vous pouvez placer le curseur à l'intérieur de la variable et appuyer sur Ctrl + Shift + P pour voir son type.

4. Long :
Le type de données Long peut avoir des valeurs comprises entre -2^63 et 2^63-1 (entier à complément à deux signé de 64 bits).
fun main(args : Array<String>) {
    val highestScore : Long = 9000
    println("$highestScore")
}

Sortie :
9000

Si vous attribuez une valeur entière supérieure à 231-1 ou inférieure à -231 à une variable (sans spécifier explicitement son type), la variable sera de type Long. Par exemple
val distance = 10000000000 // variable distance de type Long

De même, vous pouvez utiliser la lettre majuscule L pour spécifier que la variable est de type Long. Par exemple
val distance = 100L // valeur de distance de type Long

5. Double
Le type Double est une virgule flottante 64 bits à double précision.
fun main(args : Array<String>) {
    // distance est de type Double
    val distance = 999.5
    println("$distance")
}

Sortie :
999.5

6. Float :
Le type de données Float est une virgule flottante de 32 bits à simple précision. Apprenez-en plus sur la virgule flottante en simple précision et en double précision si vous êtes intéressé.
fun main(args : Array<String>) {
    // la distance est de type Float
    val distance = 19.5F
    println("$distance")
}

Sortie :
19.5

Remarquez que nous avons utilisé 19.5F au lieu de 19.5 dans le programme ci-dessus. C'est parce que 19.5 est un double littéral, et vous ne pouvez pas assigner une valeur double à une variable de type Float.Pour dire au compilateur de traiter 19.5 comme un Float, vous devez utiliser F à la fin.Si vous n'êtes pas sûr de la valeur numérique qui sera attribuée à une variable dans le programme, vous pouvez la spécifier comme type Number. Cela vous permet d'attribuer à la variable à la fois une valeur entière et une valeur flottante (une à la fois). Par exemple
fun main(args : Array<String>) {
    var test : Nombre = 12.2
    println("$test")
    test = 12
    // Int smart cast à partir de Number
    println("$test")
    test = 120L
    // Smart cast Long à partir de Number
    println("$test")
}

Sortie :
12.2
12
120

Type de données Character (Char)
Kotlin représente les caractères en utilisant char. Le caractère doit être déclaré entre guillemets simples comme 'c'. Veuillez entrer le code suivant dans notre terrain de codage et voyez comment Kotlin interprète la variable caractère. Les variables de type caractère ne peuvent pas être déclarées comme des variables numériques. Les variables Kotlin peuvent être déclarées de deux manières - l'une en utilisant "var" et l'autre en utilisant "val".
fun main(args : Array<String>) {
   val lettre : Char // Définition d'une variable
   letter = 'A' // Attribution d'une valeur à la variable
   println("$lettre")
}

Sortie :
A


Booléen
Le booléen est très simple comme les autres langages de programmation. Nous n'avons que deux valeurs pour le booléen - soit vrai, soit faux. Dans l'exemple suivant, nous allons voir comment Kotlin interprète le booléen.
fun main(args : Array<String>) {
   val lettre : Boolean // Définition d'une variable
   letter = true // Attribution d'une valeur à celle-ci
   println("La valeur de votre lettre est "+"$lettre")
}

Sortie :
La valeur de votre caractère est true

Chaînes de caractères
Les chaînes de caractères sont des tableaux de caractères. Comme Java, elles sont immuables par nature. Deux types de chaînes sont disponibles en Kotlin : l'une est appelée chaîne brute et l'autre chaîne échappée. Dans l'exemple suivant, nous allons utiliser ces chaînes de caractères.
1. Chaîne échappée : La chaîne échappée est déclarée entre guillemets (" ") et peut contenir des caractères d'échappement tels que '\n', '\t', '\b', etc.

2. String brut : La chaîne brute est déclarée entre guillemets triples (""" " ""). Elle permet de déclarer une chaîne sur de nouvelles lignes et de contenir plusieurs lignes. Row String ne peut pas contenir de caractère d'échappement.

fun main(args : Array<String>) {
   var rawString :String = "Je suis Raw String !"
   val escapedString : String = "Je suis Escaped String!\n"

   println("Bonjour !"+escapedString)
   println("Bonjour !"+chaîne brute)
}
L'exemple ci-dessus de chaîne échappée permet de fournir un espace de ligne supplémentaire après la première instruction d'impression. La sortie dans le navigateur sera la suivante.
Bonjour, je suis une chaîne échappée !
Bonjour!Je suis une chaîne brute !


Tableaux
Les tableaux sont une collection de données homogènes. Comme Java, Kotlin supporte des tableaux de différents types de données. Dans l'exemple suivant, nous allons utiliser différents tableaux.

La fonction arrayOf() crée un tableau de types wrapper. Les valeurs des éléments sont passées dans la fonction arrayOf() comme arrayOf(1,2,3) qui crée un tableau [1,2,3].

val id = arrayOf(1,2,3,4,5)
val firstId = id[0]
val lasted = id[id.size-1]

Création d'un tableau à l'aide du constructeur Array() :
Créer un tableau en utilisant le constructeur Array() prend deux arguments dans le constructeur Array() :

1. Le premier argument est la taille du tableau, et

2. Le second argument est la fonction, qui est utilisée pour initialiser et retourner la valeur de l'élément du tableau en fonction de son index.

val asc = Array(5, { i -> i * 2 }) //asc[0,2,4,6,8]  

1 vote. Moyenne 5 sur 5.