Exploration approfondie des collections immuables
Découvrez les collections immuables fondamentales telles que List, Map et Set, et apprenez à les utiliser efficacement.
Exploration approfondie des collections immuables est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.
Collections immuables : présentation
Bienvenue dans le monde des collections immuables ! En Scala, elles sont fondamentales pour écrire du code robuste, concurrent et prévisible, en particulier en programmation fonctionnelle.
Nous allons explorer des types fondamentaux comme List, Map et Set, en nous concentrant sur leur utilisation efficace et sûre.
Pourquoi l'immutabilité est importante
L'immutabilité signifie qu'une fois une collection créée, elle ne peut plus être modifiée. Toute opération qui semble la « modifier » renvoie en réalité une nouvelle collection.
- Prévisibilité : le code est plus facile à comprendre.
- Sécurité des fils d'exécution : aucun verrou n'est nécessaire, car les données ne changent jamais.
- Absence d'effets secondaires : les opérations ne modifieront pas de manière inattendue des données ailleurs.
Listes Scala : séquences ordonnées
Une List en Scala est une séquence immuable et ordonnée d'éléments d'un même type. Elle est idéale pour les données séquentielles lorsque l'ordre est important.
Vous pouvez créer une liste en énumérant simplement ses éléments.
object Main {
def main(args: Array[String]): Unit = {
val numbers = List(1, 2, 3, 4, 5)
val fruits = List("apple", "banana", "cherry")
println(s"Numbers list: $numbers")
println(s"Fruits list: $fruits")
}
}Opérations sur les listes : tête, queue et cons
Les listes proposent des opérations courantes, comme l'accès à la head (premier élément) et à la tail (reste de la liste). L'opérateur :: (cons) sert à ajouter un élément au début et crée une nouvelle liste.
object Main {
def main(args: Array[String]): Unit = {
val numbers = List(10, 20, 30)
println(s"Original list: $numbers")
println(s"Head of list: ${numbers.head}") // 10
println(s"Tail of list: ${numbers.tail}") // List(20, 30)
val newList = 5 :: numbers // Prepend 5
println(s"List with 5 prepended: $newList")
}
}Maps Scala : associations clé-valeur
Une Map est une collection immuable qui stocke des paires clé-valeur. Chaque clé est unique et est associée à une seule valeur. Les maps sont parfaites pour rechercher une valeur à partir d'une clé donnée.
object Main {
def main(args: Array[String]): Unit = {
val ages = Map("Alice" -> 30, "Bob" -> 25, "Charlie" -> 35)
val codes = Map(1 -> "One", 2 -> "Two")
println(s"Ages map: $ages")
println(s"Codes map: $codes")
}
}Opérations sur les maps : accès et mise à jour
Vous pouvez accéder aux valeurs d'une Map à l'aide de sa clé. Pour « mettre à jour » ou « ajouter » une paire clé-valeur, vous créez une nouvelle map contenant les changements, tandis que la map d'origine reste intacte.
object Main {
def main(args: Array[String]): Unit = {
val ages = Map("Alice" -> 30, "Bob" -> 25)
println(s"Original ages: $ages")
println(s"Bob's age: ${ages("Bob")}")
val updatedAges = ages + ("Charlie" -> 35) // Add new pair
println(s"Ages after adding Charlie: $updatedAges")
val changedAges = updatedAges + ("Alice" -> 31) // Update Alice's age
println(s"Ages after updating Alice: $changedAges")
}
}Ensembles Scala : éléments uniques
Un Set est une collection immuable d'éléments uniques. Contrairement aux listes, l'ordre des éléments d'un Set n'est pas garanti et les éléments en double sont automatiquement ignorés.
Les ensembles sont parfaits pour vérifier l'appartenance ou garantir l'unicité.
object Main {
def main(args: Array[String]): Unit = {
val numbers = Set(1, 2, 2, 3, 4, 3, 5)
val letters = Set('a', 'b', 'a')
println(s"Unique numbers: $numbers")
println(s"Unique letters: $letters")
}
}Opérations sur les ensembles : ajout, suppression et union
Comme pour les listes et les maps, les opérations sur les ensembles, telles que l'ajout ou la suppression d'éléments, renvoient également un nouveau Set. Vous pouvez aussi effectuer des opérations de théorie des ensembles, comme union (combinaison d'ensembles).
object Main {
def main(args: Array[String]): Unit = {
val setA = Set(1, 2, 3)
val setB = Set(3, 4, 5)
println(s"Set A: $setA")
println(s"Set B: $setB")
val addedSet = setA + 4 // Add element
println(s"Set A + 4: $addedSet")
val removedSet = setA - 2 // Remove element
println(s"Set A - 2: $removedSet")
val unionSet = setA union setB // Combine sets
println(s"Set A union Set B: $unionSet")
}
}Immutabilité : l'original reste inchangé
Il est essentiel de retenir que toutes les opérations de « modification » sur les collections immuables de Scala renvoient une nouvelle collection. La collection d'origine n'est jamais modifiée.
Ce comportement est une pierre angulaire de la programmation fonctionnelle en Scala.
object Main {
def main(args: Array[String]): Unit = {
val originalList = List(10, 20, 30)
println(s"Original List: $originalList")
val doubledList = originalList.map(_ * 2) // map returns a NEW list
println(s"List after map: $doubledList")
println(s"Original list is still: $originalList") // Unchanged!
}
}Vérifiez votre compréhension
Considérez l'extrait de code Scala suivant :
val mySet = Set(1, 2, 3)
val newSet = mySet + 3 + 4
val finalSet = newSet - 2Quelle sera la valeur de mySet après ces opérations ?
Récapitulatif : collections immuables
Vous avez étudié en profondeur les collections immuables fondamentales de Scala :
- Listes : séquences ordonnées, adaptées aux données séquentielles.
- Maps : paires clé-valeur, efficaces pour les recherches.
- Sets : éléments uniques, parfaits pour vérifier l'appartenance.
L'idée essentielle à retenir est l'immutabilité : les opérations renvoient toujours de nouvelles collections, ce qui garantit prévisibilité et sécurité.
Questions Fréquemment Posées
La leçon « Exploration approfondie des collections immuables » est-elle gratuite ?
Oui — le texte complet de « Exploration approfondie des collections immuables » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Exploration approfondie des collections immuables » ?
Découvrez les collections immuables fondamentales telles que List, Map et Set, et apprenez à les utiliser efficacement. Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « Exploration approfondie des collections immuables » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Exploration approfondie des collections immuables
- Opérations fonctionnelles sur les collections
- Option, Try et Either pour gérer les erreurs