Scala for Backend Engineering & Functional Programming · Leçon

List, Vector, Set, Map

Collections fondamentales

List, Vector, Set, Map est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. 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 4 leçons au total.

Les collections fondamentales de Scala

Scala propose plusieurs collections immuables dans sa bibliothèque standard. Les quatre que vous utiliserez le plus sont List, Vector, Set et Map. Chacune possède des performances et une sémantique différentes.

object Main {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)
    val vector = Vector(1, 2, 3)
    val set = Set(1, 2, 3)
    val map = Map("a" -> 1, "b" -> 2)
    println(list)
    println(vector)
    println(set)
    println(map)
  }
}

List : une liste chaînée

List est une liste simplement chaînée. L'ajout en tête avec :: est en O(1) et rapide, tandis que l'accès aléatoire et l'ajout en fin sont en O(n). Elle est idéale pour la récursion et les utilisations de type pile.

object Main {
  def main(args: Array[String]): Unit = {
    val xs = List(2, 3, 4)
    val prepended = 1 :: xs
    println(prepended)
    println("head: " + xs.head)
    println("tail: " + xs.tail)
  }
}

Vector : équilibré et polyvalent

Vector est une séquence indexée dont l'accès, la mise à jour, l'ajout en tête et l'ajout en fin sont effectivement en O(1). Lorsque vous avez besoin d'un accès aléatoire rapide ou d'une séquence polyvalente, préférez Vector à List.

object Main {
  def main(args: Array[String]): Unit = {
    val v = Vector(10, 20, 30, 40)
    println(v(2))
    val updated = v.updated(0, 99)
    println(updated)
    println(v :+ 50)
  }
}

Set : des éléments uniques

Un Set stocke des éléments distincts, sans doublons et sans ordre garanti. Les tests d'appartenance avec contains sont rapides.

object Main {
  def main(args: Array[String]): Unit = {
    val s = Set(1, 2, 2, 3, 3, 3)
    println(s)
    println(s.contains(2))
    println(s + 4)
    println(s - 1)
  }
}

Opérations sur les Set

Les ensembles prennent en charge des opérations mathématiques : union (|), intersect (&) et diff (−−).

object Main {
  def main(args: Array[String]): Unit = {
    val a = Set(1, 2, 3)
    val b = Set(2, 3, 4)
    println(a union b)
    println(a intersect b)
    println(a diff b)
  }
}

Map : des paires clé-valeur

Une Map associe des clés à des valeurs. Les clés sont uniques. Créez des entrées avec la flèche -> et recherchez des valeurs avec get (qui renvoie un Option) ou apply.

object Main {
  def main(args: Array[String]): Unit = {
    val ages = Map("Ann" -> 30, "Bob" -> 25)
    println(ages("Ann"))
    println(ages.get("Cara"))
    println(ages.getOrElse("Cara", 0))
  }
}

Mettre à jour une Map immuablement

Les Map immuables renvoient une nouvelle Map lorsque vous ajoutez ou supprimez des entrées ; l'originale reste inchangée. Utilisez + pour ajouter ou remplacer une entrée et - pour en supprimer une.

object Main {
  def main(args: Array[String]): Unit = {
    val m = Map("a" -> 1)
    val m2 = m + ("b" -> 2)
    val m3 = m2 - "a"
    println(m)
    println(m2)
    println(m3)
  }
}

Parcourir une Map

Parcourir une Map vous fournit des tuples clé-valeur. Vous pouvez les déstructurer directement dans une for-comprehension ou avec une correspondance de motifs.

object Main {
  def main(args: Array[String]): Unit = {
    val scores = Map("math" -> 90, "art" -> 75)
    for ((subject, score) <- scores) {
      println(s"$subject: $score")
    }
  }
}

Méthodes communes à toutes les collections

Toutes ces collections partagent une grande API commune : size, isEmpty, map, filter, foreach, et bien d'autres. Apprenez cette API une fois, puis utilisez-la partout.

object Main {
  def main(args: Array[String]): Unit = {
    println(List(1, 2, 3).map(_ * 2))
    println(Vector(1, 2, 3).map(_ * 2))
    println(Set(1, 2, 3).map(_ * 2))
  }
}

Convertir des collections

Les méthodes de conversion comme toList, toVector, toSet et toMap permettent de changer facilement de type. La conversion en Set supprime les doublons.

object Main {
  def main(args: Array[String]): Unit = {
    val withDupes = List(1, 1, 2, 3, 3)
    println(withDupes.toSet)
    val pairs = List(("a", 1), ("b", 2))
    println(pairs.toMap)
  }
}

Choisir la collection appropriée

Guide rapide :

List — récursion, ajout rapide en tête, traitement de la tête et de la queue
Vector — usage général, accès indexé rapide
Set — unicité et tests d'appartenance
Map — recherches fondées sur des clés

object Main {
  def main(args: Array[String]): Unit = {
    val ids = List(5, 3, 5, 1, 3)
    val unique = ids.toSet
    val indexed = ids.toVector
    println(s"unique count: ${unique.size}")
    println(s"third element: ${indexed(2)}")
  }
}

Vérification rapide

Quelle collection supprime automatiquement les éléments en double ?

Récapitulatif

Vous avez découvert les collections immuables fondamentales de Scala :

List — liste chaînée, ajout rapide en tête
Vector — accès indexé, performances bien équilibrées
Set — éléments uniques et algèbre des ensembles
Map — recherches clé-valeur avec get/getOrElse

Elles partagent une API commune riche et se convertissent facilement les unes dans les autres.

Questions Fréquemment Posées

La leçon « List, Vector, Set, Map » est-elle gratuite ?

Oui — le texte complet de « List, Vector, Set, Map » 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « List, Vector, Set, Map » ?

Collections fondamentales 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 4.

Combien de temps prend la leçon « List, Vector, Set, Map » ?

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

← Retour à Scala for Backend Engineering & Functional Programming