Elemente an Liste in Scala anhängen
In diesem Artikel lernen wir, wie man mit Scalas Liste arbeitet und sehen verschiedene Möglichkeiten, Elemente an die Liste anzuhängen.
Eine Liste in Scala ist eine Sammlung, die verwendet wird, um sequentielle und ähnliche Arten von Daten zu speichern. Sie werden verwendet, um verkettete Listen in Scala darzustellen.
Genau wie Strings in Java sind Listen in Scala unveränderlich. Unveränderlich bedeutet, dass eine einmal mit einigen Elementen deklarierte Liste nicht modifiziert oder verändert werden kann.
Liste in Scala deklarieren und initialisieren
Syntax:
val listName: List[list type] = List()
Beispielcode:
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)
}
}
Ausgabe:
Integer List :
List(1, 2, 3)
String List :
List(IronMan, Hulk, BatMan)
Anhängen von Elementen am Ende der Liste in Scala
Da Scala-Listen unveränderlich sind, erstellen wir eine neue Liste aus der vorhandenen Liste, der neue Elemente hinzugefügt werden.
Methode 1
Verwenden der :+-Methode, um ein Element an das Ende der Liste in Scala anzuhängen.
Syntax:
list_name:+new_element
Beispielcode:
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)
}
}
Ausgabe:
Present List :
List(Tony, Stark, is)
New List :
List(Tony, Stark, is, Iron Man)
Die gleiche Methode könnte verwendet werden, um die Werte am Anfang der Liste voranzustellen, d. h. anzuhängen.
Beispielcode:
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)
}
}
Ausgabe:
Present List :
List(Tony, Stark)
New List :
List(Hero, Tony, Stark)
Methode 2:
Verwendung von ::: in Scala, um zwei Listen zu verketten. Diese Methode ist nützlich, wenn Sie versuchen, mehrere Werte an eine Liste anzuhängen.
Syntax:
list1 ::: list2
Beispielcode:
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)
}
}
Ausgabe:
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)
Methode 3:
Die Idee dabei ist, veränderliche Datenstrukturen wie ListBuffer zu verwenden. Hier haben wir die Methoden += und append, um Elemente an die Liste anzuhängen.
Beispielcode:
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)
}
}
Ausgabe:
Modified list:
ListBuffer(Welcome, To, Scala, Programming, it, is, very, easy)
