Ajouter des éléments à la liste dans Scala
- Déclaration et initialisation de la liste dans Scala
- Ajouter des éléments à la fin de la liste dans Scala
Dans cet article, nous allons apprendre à travailler avec la liste de Scala et voir différentes façons d’ajouter des éléments à la liste.
Une liste dans Scala est une collection utilisée pour stocker des types de données séquentiels et similaires. Ils sont utilisés pour représenter des listes chaînées dans Scala.
Tout comme les chaînes en Java, les listes sont immuables en Scala. Immuable signifie qu’une fois qu’une liste est déclarée avec certains éléments, elle ne peut plus être modifiée ou altérée.
Déclaration et initialisation de la liste dans Scala
Syntaxe:
val listName: List[list type] = List()
Exemple de code :
object Main {
def main(args:Array[String])
{
//Immutable Integer type list
val mylist1: List[Int] = List(1,2,3)
//Immutable String type list
val mylist2: List[String] = List("IronMan","Hulk","BatMan")
println("Integer List :")
println(mylist1)
println("String List :")
println(mylist2)
}
}
Production :
Integer List :
List(1, 2, 3)
String List :
List(IronMan, Hulk, BatMan)
Ajouter des éléments à la fin de la liste dans Scala
Comme les listes Scala sont immuables, nous créons une nouvelle liste à partir de la liste existante avec de nouveaux éléments ajoutés.
Méthode 1
Utilisation de la méthode :+ pour ajouter un élément à la fin de la liste dans Scala.
Syntaxe:
list_name:+new_element
Exemple de code :
object Main {
def main(args:Array[String])
{
//Immutable String type list
val mylist1: List[String] = List("Tony","Stark","is")
println("Present List :")
println(mylist1)
// new list created using the existing list plus the new element
val newlist = mylist1 :+ "Iron Man"
println("New List :")
println(newlist)
}
}
Production :
Present List :
List(Tony, Stark, is)
New List :
List(Tony, Stark, is, Iron Man)
La même méthode pourrait être utilisée pour préfixer, c’est-à-dire ajouter les valeurs au début de la liste.
Exemple de code :
object Main {
def main(args:Array[String])
{
//Immutable String type list
val mylist1: List[String] = List("Tony","Stark")
println("Present List :")
println(mylist1)
val newlist: List[String] = "Hero" +: mylist1
println("New List :")
println(newlist)
}
}
Production :
Present List :
List(Tony, Stark)
New List :
List(Hero, Tony, Stark)
Méthode 2 :
Utiliser ::: dans Scala pour concaténer deux listes. Cette méthode est avantageuse lorsque vous essayez d’ajouter plusieurs valeurs à une liste.
Syntaxe:
list1 ::: list2
Exemple de code :
object Main {
def main(args:Array[String])
{
val mylist1: List[Int] = List(1,2,3,4)
println("List 1:")
println(mylist1)
val mylist2: List[Int] = List(11,22,33,55)
println("List 2:")
println(mylist2)
//appending list2 to list1
val mylist3: List[Int] = mylist1:::mylist2
println("Appended list:")
println(mylist3)
}
}
Production :
List 1:
List(1, 2, 3, 4)
List 2:
List(11, 22, 33, 55)
Appended list:
List(1, 2, 3, 4, 11, 22, 33, 55)
Méthode 3 :
L’idée ici est d’utiliser des structures de données mutables comme ListBuffer. Ici, nous avons les méthodes += et append pour ajouter des éléments à la liste.
Exemple de code :
import scala.collection.mutable.ListBuffer
object Main {
def main(args:Array[String])
{
var myList1 = new ListBuffer[String]()
//appending values to the list
myList1+="Welcome"
myList1+="To"
myList1+=("Scala","Programming") //multiple values
myList1.append("it","is","very","easy")
println("Modified list:")
println(myList1)
}
}
Production :
Modified list:
ListBuffer(Welcome, To, Scala, Programming, it, is, very, easy)
