Collecte de listes
Les collections Kotlin sont divisées en collections mutables et collections immuables. Les collections immuables signifient que la collection ne peut être utilisée qu'en lecture et ne peut pas être ajoutée, modifiée ou supprimée.
1. Collections immuables
val fruits = listOf<String>("apple","orange","pear")
2. Collecte de variables
fun main() {
val names = mutableListOf("Tom", "Lucky", "Daniel")
names.add("Alice")
names+= "Sara"
for (name in names){
print("$name - ")
}
}
3. Conversion du type de collection
Collection immuable à collection mutabletoMutableList()
fun main() {
val fruits = listOf("apple", "orange", "pear")
val newFruits = fruits.toMutableList()
newFruits.add("kiwi")
println(fruits)
println(newFruits)
}
//运行结果：
[apple, orange, pear]
[apple, orange, pear, kiwi]
Collection mutable à collection immuable :toList()
fun main() {
val names = mutableListOf("Tom", "Lucky", "Daniel")
val newNames = names.toList()
names.add("Alice")
println(names)
println(newNames)
}
//运行结果：
[Tom, Lucky, Daniel, Alice]
[Tom, Lucky, Daniel]
Notez que l'appel de la fonction de type de collection de conversion générera un nouvel objet de collection et que le type d'origine ne sera pas affecté.
4. Lire les éléments de collection
fun main() {
val fruits = listOf("apple", "orange", "pear")
println(fruits.get(2))//Should be replaced with indexing
println(fruits[2])
}
Il existe deux manières de lire les éléments. La première consiste à l'utiliser comme Java get, mais le compilateur Kotlin vous demandera : Doit être remplacé par l'indexation, qui préconise l'utilisation de crochets et l'indexation pour lire des éléments tels que des tableaux en Java.
fun main() {
val fruits = listOf("apple", "orange", "pear")
println(fruits[5])
}
Lorsque vous utilisez l'index pour lire des éléments, il est facile d'avoir le risque d'un tableau hors limites, par exemple, le code ci-dessus signale une erreur : out-of-bounds ArrayIndexOutOfBoundsException.
Pour résoudre les hors-limites, vous pouvez utiliser la méthode de valeur d'index sûre : getOrElseou getOrNull. getOrElseTransmettez l'index et l'expression Lambda renvoyée après une erreur, getOrNulltransmettez l'index, s'il n'est pas trouvé, renvoyez yes null.
fun main() {
val fruits = listOf("apple", "orange", "pear")
println(fruits.getOrElse(4) {
"IndexOutOfBounds"
})
println(fruits.getOrNull(4))
println(fruits.getOrNull(4) ?: "IndexOutOfBounds")
}
5. Traversée des éléments de la collection
fun main() {
val names = mutableListOf("Tom", "Lucky", "Daniel")
for (name in names){
print("$name - ")
}
println()
names.forEach{
print("$it * ")
}
println()
//遍历同时获取索引
names.forEachIndexed{
index,item ->
print("$index-$item & ")
}
}
运行结果：
Tom - Lucky - Daniel -
Tom * Lucky * Daniel *
0-Tom & 1-Lucky & 2-Daniel &
Collecte de cartes
1. Collections immuables
val fruits = mapOf("apple" to 2.5, "orange" to 5, "pear" to 3)
Ici keyla valeur et valueest toreliée par , mais toce n'est pas un mot clé, mais une infixfonction.
2. Collecte de variables
fun main() {
//初始化方式一
var fruits = mutableMapOf("apple" to 2.5, "orange" to 5, "pear" to 3)
//初始化方式二
var fruitList = mutableMapOf(Pair("apple",2.5) ,Pair("orange",5),Pair("pear",3))
//添加元素
fruits.put("kiwi",6)//不推荐
fruits["banana"] = 5//推荐
fruits += "watermelon" to 10
for ((key, value) in fruits){
println("$key's price is $value")
}
}
3. Conversion du type de collection
fun main() {
val fruits = mapOf("apple" to 2.5, "orange" to 5, "pear" to 3)
val newFruits = fruits.toMutableMap()
newFruits.put("kiwi",6)
println(newFruits)
var fruits = mutableMapOf("apple" to 2.5, "orange" to 5, "pear" to 3)
println(fruits.toMap())
}
4. Lire les éléments de collection
fun main() {
val fruits = mapOf("apple" to 2.5, "orange" to 5, "pear" to 3)
println(fruits["apple"])
println(fruits.getValue("apple"))
println(fruits.getOrElse("banana") {
"banana has not price" })
println(fruits.getOrDefault("banana", 0))
}
//运行结果
2.5
2.5
banana has not price
0
5. Traversée des éléments de la collection
fun main() {
val fruits = mapOf("apple" to 2.5, "orange" to 5, "pear" to 3)
fruits.forEach {
println("${
it.key} + ${
it.value} ")
}
}
//运行结果：
apple + 2.5
orange + 5
pear + 3
Ensemble de collecte
1. Collections immuables
val set = setOf("apple", "orange", "pear", "pear")
2. Collecte de variables
val mutableSet = mutableSetOf("apple", "orange", "pear", "pear")
3. Conversion du type de collection
fun main() {
val set = setOf("apple", "orange", "pear", "pear")
val newSet = set.toMutableSet();
newSet.add("banana")
newSet += "kiwi"
//添加元素
println(newSet)
val mutableSet = mutableSetOf("apple", "orange", "pear", "pear")
println(mutableSet.toSet())
}
4. Lire les éléments de collection
fun main() {
val set = setOf("apple", "orange", "pear", "pear")
println(set.elementAt(1))
}
//运行结果：orange
5. Traversée des éléments de la collection
fun main() {
val set = setOf("apple", "orange", "pear", "pear")
set.forEach{
print("$it ")
}
}
//运行结果
apple orange pear
Remarque : par rapport à la liste, l'ensemble a une caractéristique selon laquelle les données de l'ensemble sont différentes et uniques, de sorte qu'il n'y en a qu'une imprimée dans l'exemple ci-dessus "pear".
Deux façons de dédupliquer List :
fun main() {
val list = listOf("apple", "orange", "pear", "pear")
//去重方式1
val newList = list.toSet().toList()
println(list)
println(newList)
//去重方式2 快捷函数distinct
val newList1 = list.distinct()
println(list)
println(newList1)
}
//运行结果
[apple, orange, pear, pear]
[apple, orange, pear]
[apple, orange, pear, pear]
[apple, orange, pear]
Certains des opérateurs utilisés ci-dessus lors de l'ajout d'éléments. Les amis qui ne comprennent pas peuvent lire un autre article Kotlin Learning - Operator Overloading
API fonctionnelle pour les collections
API- maxByOrNull
Voici une exigence pour trouver le fruit avec le nom de fruit le plus long dans la liste ci-dessus :
fun main() {
val fruits = listOf<String>("apple", "orange", "pear", "watermelon")
val maxLengthFruit = fruits.maxByOrNull {
it.length }
println(maxLengthFruit)
}
//运行结果：watermelon
Ce qui est utilisé ici maxByOrNullest l'API fonctionnelle de l'ensemble, qui est utilisée pour filtrer les plus grands qui remplissent les conditions selon les expressions Lambda entre les accolades.
1. Utilisation des expressions Lambda
Structure de la syntaxe Lambda :
{nom du paramètre 1 : type de paramètre, nom du paramètre 2 : type de paramètre -> corps de la fonction}
maxByOrNullUne fonction nécessite une expression Lambda, écrite à l'origine comme suit :
val lambda = {
fruit: String -> fruit.length }
val maxLengthFruit = fruits.maxByOrNull(lambda )
2. Ecriture simplifiée des expressions Lambda
Dans de nombreux cas, nous n'avons pas besoin d'utiliser la structure grammaticale complète des expressions Lambda, mais il existe de nombreuses façons simplifiées de les écrire.
1) Transmettez l'expression Lambda directement dans la fonction au lieu de la déclarer séparément :
val maxLengthFruit = fruits.maxByOrNull({
fruit: String -> fruit.length })
2) Lorsque le paramètre Lambda est le dernier paramètre de la fonction, l'expression Lambda peut être déplacée en dehors des crochets de la fonction :
val maxLengthFruit = fruits.maxByOrNull(){
fruit: String -> fruit.length }
3) Si le paramètre Lambda est le seul paramètre de la fonction, les parenthèses de la fonction peuvent également être omises
val maxLengthFruit = fruits.maxByOrNull{
fruit: String -> fruit.length }
4) Étant donné que Kotlin dispose d'un excellent mécanisme de dérivation de type, le type de paramètre d'entrée peut être supprimé :
val maxLengthFruit = fruits.maxByOrNull{
fruit -> fruit.length }
5) Lorsqu'il n'y a qu'un seul paramètre dans la liste des paramètres de l'expression Lambda, il n'est pas nécessaire de déclarer le nom du paramètre, mais itdes mots clés peuvent être utilisés à la place :
val maxLengthFruit = fruits.maxByOrNull {
it.length }
Après une série de changements ci-dessus, j'ai finalement obtenu la déclaration que je viens de commencer à écrire.
3. Exercice : en imitant l'exemple ci-dessus, vous pouvez écrire un filtre pour sélectionner le fruit au prix le plus élevé parmi les fruits :
fun main() {
var fruitsMap = mutableMapOf("apple" to 2.5, "orange" to 5, "pear" to 3)
val maxPriceFruit = fruitsMap.maxByOrNull {
it.value.toFloat() }
println(maxPriceFruit?.key)
}
//运行结果：orange
API- map
L'API mapmappe chaque élément de la collection à une autre valeur, les règles de mappage sont spécifiées dans l'expression Lambda et enfin une nouvelle collection est générée.
fun main() {
val fruits = listOf<String>("apple", "orange", "pear", "watermelon")
val newFruitList = fruits.map {
it.uppercase() }
println(newFruitList)
}
//[APPLE, ORANGE, PEAR, WATERMELON]
API- filter
filterLes fonctions sont utilisées pour filtrer les données dans une collection, et elles peuvent être utilisées seules ou avec mapdes fonctions.
Exigence : Convertir les fruits dont les noms sont plus longs que 5 en majuscules
fun main() {
val fruits = listOf<String>("apple", "orange", "pear", "watermelon")
val newFruitList = fruits.filter {
it.length > 5 }.map {
it.uppercase() }
println(newFruitList)
}
//[ORANGE, WATERMELON]
API - anyetall
anyLa fonction est utilisée pour juger s'il y a au moins un élément dans la collection qui satisfait la condition spécifiée, et allla fonction est utilisée pour juger si tous les éléments de la collection remplissent la condition spécifiée.
fun main() {
val fruits = listOf<String>("apple", "orange", "pear", "watermelon")
val anyResult = fruits.any {
it.length > 5 }
val allResult = fruits.all {
it.length > 5 }
println("anyResult: $anyResult | allResult: $allResult")
}
//anyResult: true | allResult: false
Ouvrage de référence pour cet article : "La première ligne de code" - Guo Lin