Cours
Introduction à Scala
3 h
27.1K
Vous pourriez également être intéressé par les tutoriels suivants :
Introduction
Une liste simplement chaînée, implémentant une liste avec 3 entiers (Source : Wikipedia - List (abstract data type)).
Une liste, au sens général, est une suite d’éléments (type de données abstrait) représentant un nombre fini de valeurs. Ces valeurs peuvent être manipulées par un programme et apparaître plusieurs fois dans une même liste. L’illustration ci-dessus montre une instance de liste sous forme de liste simplement chaînée composée de trois entiers. La liste est également considérée comme une structure de données ; un exemple typique de liste en tant que structure de données est la liste chaînée.
De nombreux langages de programmation prennent en charge les listes, et Python en est un exemple où elles sont largement utilisées. Une liste peut souvent être construite en écrivant les éléments à la suite, séparés par des virgules, des points-virgules ou des espaces, et encadrés par des délimiteurs comme des parenthèses (), des crochets [], des accolades {} ou des chevrons <>. Certains langages comme Python permettent d’indexer ou de « slicer » les listes comme des tableaux ; dans ce cas, on parle plus justement de tableau (Source : Wikipedia - List (abstract data type)).
Spécifique à Scala, une liste est une collection qui contient des données immutables : une fois créée, elle ne peut plus être modifiée. En Scala, la liste représente une liste chaînée.
Dans une liste Scala, chaque élément n’a pas besoin d’être du même type. L’implémentation des listes Scala utilise un état mutable en interne pendant la phase de construction. En Scala, la liste est définie dans le package scala.collection.immutable ; elle est donc immuable. Enfin, une liste Scala propose diverses méthodes comme add, prepend, max, min, etc.
Syntaxe pour définir une liste Scala
val variable_name: List[type] = List(item1, item2, item3) ou val variable_name = List(item1, item2, item3). Une liste en Scala ressemble beaucoup à un tableau Scala. Cependant, la liste Scala est immuable et représente une structure de données chaînée, tandis qu’un tableau Scala est plat et mutable.
Voyons rapidement cette différence à l’aide d’un exemple.
Liste Scala vs. tableau Scala
Commençons par définir un tableau en Scala.
Puis modifiez la valeur à l’indice 1 (les tableaux Scala sont indexés à partir de zéro) et vérifiez si la mise à jour est possible.
Comme vous pouvez le voir dans l’extrait ci-dessus, le tableau Scala vous a bien permis de modifier la valeur à l’indice 1.
Maintenant, définissez une liste Scala et tentez la même opération.
Comme le montre l’exemple, les listes Scala étant immuables, la tentative de mise à jour a provoqué une erreur.
Méthodes des listes Scala
-
head : retourne le premier élément de la liste.
-
tail : retourne tous les éléments sauf le premier.
-
isEmpty : vérifie si la liste est vide et renvoie True le cas échéant, sinon False.
-
fill() : crée une liste uniforme composée de zéro ou plusieurs copies de l’élément indiqué.
-
reverse : inverse l’ordre des éléments de la liste.
-
$:::$ ou $.:::$ ou .concat() : concatène deux listes ou plus.
-
tabulate() : permet de tabuler une liste. Dans l’esprit, c’est proche de
fill(), mais à la différence defill(), elle prend deux arguments : le premier précise les dimensions de la liste à créer, le second décrit les éléments de la liste, calculés par une fonction.
Pas d’inquiétude si certaines méthodes ci-dessus vous semblent encore abstraites : vous allez les mettre en œuvre en Scala avec un exemple. Mais commençons par apprendre à définir des listes Scala.
Vous allez créer des listes Scala avec des chaînes de caractères, des entiers (en 1D et 2D). Vous verrez aussi comment créer une liste mêlant chaînes et entiers.
Liste d’entiers 1D
Liste 1D mêlant entiers et chaînes
Liste de chaînes 1D
Liste 2D
Opérations arithmétiques sur des listes
Dans cet exemple, vous utiliserez des listes plutôt que de simples variables. Contrairement à une variable, une liste peut contenir n valeurs ; vous effectuerez donc des opérations arithmétiques sur deux listes au lieu de deux variables.
Voyons rapidement comment procéder.
Pour appliquer les opérations arithmétiques, vous utiliserez la fonction zipped.map sur les listes x et y. Vous indiquerez ensuite l’opération à effectuer en argument de la méthode zipped.map.
Pour finir, écrivons un code qui regroupe toutes ces méthodes.
object Scala_List_Methods
{
def main(args: Array[String])
{
// define two lists
val x = List(1, 40, 10)
val y = List(20, 25, 30)
val z = List("DataCamp", "Tutorials", "Are", "The", "Best")
//Head
println();
println("Head of list x, y, z = " + (x.head, y.head, z.head));
println();
//Tail
println("Tail of list x, y, z = " + (x.tail, y.tail, z.tail));
println();
//isEmpty
println("Is list x, y, z empty? = " + (x.isEmpty, y.isEmpty, z.isEmpty));
println();
//Concatenate
println("Concatenating x, y, z lists with the first method = " + (x:::y:::z));
println("Concatenating x, y, z lists with the second method = " + ((x).:::(y).:::(z)));
println("Concatenating x, y, z lists with the third method = " + (List.concat(x,y,z)));
println();
//Reverse
println("Reverse of x, y, z is = " + (x.reverse, y.reverse, z.reverse));
println();
//Fill
println("Output of Fill method is = " + (List.fill(5)(z)));
println();
//Tabulate
println("Output of Tabulate method is = " + (List.tabulate(5)(x => x * x * x)));
}
}
Conclusion
Félicitations pour avoir terminé ce tutoriel Scala.
N’hésitez pas à poser vos questions sur ce tutoriel dans les commentaires ci-dessous.
Sujets