Structure de données immuable / Blogs / Perficient

Scala, un langage de programmation qui combine des paradigmes de programmation orientés objet et fonctionnels, fournit une variété de structures de données immuables. Les structures de données immuables sont celles qui ne peuvent pas être modifiées après leur création, ce qui peut être bénéfique pour garantir la sécurité et la simplicité de la programmation simultanée ou parallèle. Voici quelques structures de données immuables couramment utilisées dans Scala :

• Liste
• Ensemble
• Carte
• Tuple
• Vecteur
• Gamme

Explorons quelques structures de données immuables.

1. Liste:

La liste est une collection ordonnée et immuable d’éléments du même type. Il représente une structure de données de liste chaînée.

Exemple:

val immutableList = List(1, 2, 3)

Dans l’exemple, immutableList est créé avec trois éléments : 1, 2 et 3. Une fois une liste créée, ses éléments ne peuvent plus être modifiés. Toute opération qui semble modifier la liste renvoie une nouvelle liste.

Opérations courantes sur les listes immuables :

val firstElement = immutableList.head // 1
val restOfTheList = immutableList.tail // List(2, 3)

• Préfixe et ajout :

val newList = 0 +: immutableList // List(0, 1, 2, 3)
val anotherList = immutableList :+ 4 // List(1, 2, 3, 4)

val combinedList = immutableList ++ List(4, 5) // List(1, 2, 3, 4, 5)

val evenNumbers = immutableList.filter(_ % 2 == 0) // List(2)
val squaredList = immutableList.map(x => x * x) // List(1, 4, 9)

Les listes immuables dans Scala offrent un moyen pratique et sûr de travailler avec des séquences d’éléments. L’immuabilité garantit que les opérations sur les listes ne modifient pas la liste d’origine, favorisant ainsi les principes de programmation fonctionnelle. Ceci est particulièrement avantageux dans la programmation simultanée et parallèle, car cela réduit le risque de problèmes d’état mutable partagé. Bien que des listes mutables existent dans Scala (scala.collection.mutable.ListBuffer), l’utilisation de listes immuables est généralement préférée pour des raisons de clarté, de prévisibilité et de sécurité des threads.

2. Ensemble:

Set est une collection immuable dans Scala qui représente une collection désordonnée d’éléments uniques. Il n’autorise pas les éléments en double.

Exemple:

val immutableSet = Set(1, 2, 3)

Dans l’exemple, immutableSet est créé avec trois éléments : 1, 2 et 3. Une fois qu’un ensemble est créé, il ne peut pas être modifié. Les opérations sur l’ensemble renvoient un nouvel ensemble.

Opérations courantes sur les ensembles immuables :

• Ajout et suppression d’éléments :

val newSet = immutableSet + 4 // Set(1, 2, 3, 4)
val anotherSet = immutableSet - 2 // Set(1, 3)

• Union, intersection et différence :

val combinedSet = immutableSet ++ Set(3, 4, 5) // Set(1, 2, 3, 4, 5)
val commonElements = immutableSet.intersect(Set(2, 3, 4)) // Set(2, 3)
val differenceSet = immutableSet.diff(Set(2, 3)) // Set(1)

val containsTwo = immutableSet.contains(2) // true

Les ensembles immuables dans Scala permettent de travailler avec des éléments uniques dans une collection sans autoriser les doublons. L’immuabilité garantit que toute opération sur un ensemble crée un nouvel ensemble, ce qui est bénéfique pour la programmation fonctionnelle. Les ensembles immuables sont thread-safe et adaptés à la programmation simultanée et parallèle, car il n’y a aucun risque associé à l’état mutable partagé. Bien que des ensembles mutables (scala.collection.mutable.Set) existent dans Scala, l’utilisation d’ensembles immuables est généralement recommandée pour leur sécurité et leur respect des principes de programmation fonctionnelle.

3. Carte:

Map est une collection immuable dans Scala qui représente une collection de paires clé-valeur. Chaque clé est associée à exactement une valeur et les clés sont uniques dans la carte.

Exemple:

val immutableMap = Map("one" -> 1, "two" -> 2, "three" -> 3)

Dans l’exemple, immutableMap est créé avec trois paires clé-valeur. Une fois qu’une carte est créée, elle ne peut plus être modifiée. Les opérations sur la carte renvoient une nouvelle carte.

Opérations courantes sur les cartes immuables :

val valueForTwo = immutableMap("two") // 2

• Ajout et suppression d’entrées :

val newMap = immutableMap + ("four" -> 4) // Map("one" -> 1, "two" -> 2, "three" -> 3, "four" -> 4)
val anotherMap = immutableMap - "two" // Map("one" -> 1, "three" -> 3)

val mergedMap = immutableMap ++ Map("three" -> 33, "four" -> 4) // Map("one" -> 1, "two" -> 2, "three" -> 33, "four" -> 4)

val containsTwoKey = immutableMap.contains("two") // true

Les cartes immuables dans Scala offrent un moyen pratique de représenter les associations entre les clés et les valeurs. L’immuabilité garantit que les opérations sur les cartes ne modifient pas la carte d’origine, conformément aux principes de programmation fonctionnelle. Les cartes immuables sont sûres pour la programmation simultanée et parallèle, réduisant ainsi le risque d’état mutable partagé. Bien qu’il existe des cartes mutables (scala.collection.mutable.Map), l’utilisation de cartes immuables est généralement recommandée pour des raisons de clarté, de prévisibilité et de sécurité des threads dans des contextes de programmation fonctionnelle.

Collections immuables (à partir du package scala.collection.immutable) :

Scala fournit diverses autres collections immuables telles que Queue, Stack, LinkedList, etc.

Les références:

Voici les documents Spark approfondissant la création de structures de données immuables dans Scala.

Documentation officielle Spark : https://spark.apache.org/docs/latest/api/scala/scala/index.html

https://docs.scala-lang.org/overviews/collections/overview.html#:~:text=By%20default%2C%20Scala%20always%20picks%20immutable%20collections.%20For,the%20default%20bindings% 20importé%20de%20le%20scala%20package.

En conclusion, les structures de données immuables dans Scala jouent un rôle crucial dans la programmation fonctionnelle en favorisant l’immuabilité, la transparence référentielle et la sécurité des threads. L’immuabilité garantit que les opérations sur ces structures ne modifient pas les instances existantes mais en créent de nouvelles. Cela permet d’écrire du code moins sujet aux erreurs, plus facile à raisonner et plus sûr dans des environnements simultanés ou parallèles. Il s’aligne également sur les principes de la programmation fonctionnelle, où éviter les états mutables est un concept clé.