List Funktionen
scala.collection.immutable.List (API
)
Für die Klasse List sind eine Fülle nützlicher Funktionen definiert.
Viele der beschriebenen Funktionen sind nicht ausschließlich für die Klasse
oder in der Klasse List definiert.
Auch wenn es anders erscheint, wird keine List durch den Aufruf einer Funktion
verändert. Würde eine List durch eine Funktion verändert, würde
es sich bei einer List nicht um einen unveränderlichen Datentyp
handeln. Nachfolgend sollen ausgewählte Funktionen der Klasse List
vorgestellt werden.
++ |
Verbindet eine List mit den Elementen einer traversablen Collection.
|
+: |
Erzeugt eine neue List bestehend aus einem hinzuzufügendem
Element, gefolgt von der Ausgangsliste.
|
:: |
Erzeugt eine List bestehend aus einem neuen Element und einer
List.
|
::: |
Verbindet zwei List Objekte zu einer neuen List.
|
apply |
Liefert das Element welches sich an der zu übergebenden Stelle befindet. |
contains |
Überprüft, ob ein Element in der Liste enthalten ist. |
count |
Ermittelt die Anzahl Elemente, die eine definierte Bedinung erfüllen. |
drop
|
Erzeugt eine neue List mit den Elementen der Ursprungsliste,
ohne die ersten, im Parameter angegebenen, n Elemente.
|
dropRight |
Erzeugt eine neue List mit den Elementen der Ursprungsliste,
ohne die letzten, im Parameter angegebenen, n Elemente.
|
equals |
Überprüft die Gleichheit der Objekte. |
exists
|
Überprüft, ob zumindest ein Element der Liste die Anforderung der übergebenen Funktion entspricht. |
filter |
Erzeugt eine Liste bestehend aus Elementen der Ausgangsliste, die eine zu definierende Bedinung erfüllen. |
filterNot |
Erzeugt eine Liste bestehend aus Elementen der Ausgangsliste, die eine zu definierende Bedingung nicht erfüllen. |
find |
Findet das erste Element, welches der als Parameter übergebenen Argument genügt. |
foldLeft |
Wendet einen Binäroperator auf einen Startwert und nacheinander allen
Elementen der List an.
|
forall |
Überprüft, ob alle Elemente die übergebene Bedingung erfüllt. |
forall |
Überprüft, ob alle Elemente die übergebene Bedingung erfüllt. |
foreach |
foreach liefert nacheinander die Elemente der Liste, auf die
foreach aufgerufen wird.
|
head |
Liefert das erste Element der List. |
last
|
Liefert das letzte Element der List.
|
length |
Liefert die Anzahl Elemente in der List. |
map |
Erzeugt eine neue Liste durch Anwendung einer Funktion auf alle Elemente der Ausgangsliste |
reduceLeft |
Iteriert paarweise über die Liste und wertet die übergebene Funktion auf die übergebenen Parameter aus. |
reverse |
Liefert eine List mit allen Elementen der Ursprungsliste,
wobei die Elemente in umgekehrter Reihenfolge enthalten sind.
|
size |
Liefert die Anzahl Elemente in der List
|
tail |
Liefert eine neue List, ohne das erste Element der List
auf dem tail aufgerufen wurde.
|
toSet |
Erzeugt aus einer List ein Set.
|
++
def ++ [B] (that: GenTraversableOnce[B]): List[B] def ++ [B >: A, That] (that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]): That def ++ [B >: A, That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]): That
Mit ++ wird auf Basis einer List eine neue List erzeugt,
die aus den Elementen der List besteht und aus den Elementen der als Parameter
übergebenen traversablen Collection.
Das nachfolgende Beispiel zeigt die Erzeugung einer List aus einer List
und einem Array.
object PlusPlus {
def main(args: Array[String]) {
val list = List(1,2,3,4,5)
val array = Array(6,7,8,9)
val list2 = list ++ array
println(list2)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
List(1, 2, 3, 4, 5, 6, 7, 8, 9)
+:
def +: (elem: A): List[A] def +: [B >: A, That] (elem: B)(implicit bf: CanBuildFrom[List[A], B, That]): That
Erzeugt eine neue List bestehend aus einem hinzuzufügendem
Element, gefolgt von der Ausgangsliste.
object PrependIt {
def main(args: Array[String]) {
val list = List(1,2,3,4)
val list2 = 5 +: list
println(list2)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
List(5, 1, 2, 3, 4)
::
def :: (x: A) : List[A] def :: [B >: A] (x: B): List[B]
Die Funktion :: erzeugt eine neue List bestehend
aus dem in der Funktion übergebenem Argumentes gefolgt vom Inhalt
der Liste auf der :: aufgerufen wurde.
Nachfolgend ein Skript Beispiel zur Funktion :: in Punkt-Schreibweise.
val list1 = List(2,3,4) val list2 = list1.::(1) println(list1) println(list2)
Die Ausführung dieses Skriptes führt zur folgenden Ausgabe auf der Systemausgabe:
List(2, 3, 4) List(1, 2, 3, 4)
Wie bei der Funktion ::: ist bei der Funktion :: die
Operator-Schreibweise geläufiger. Da der Funktionsnname mit einem Doppelpunkt
endet, wird diese bei der Operator-Schreibweise auf den rechten Operanden
mit dem linken Operanden als Argument aufgerufen.
Das nachfolgende Skript entspricht dem obigen in Operator-Schreibweise und führt bei dessen Ausgabe zum gleichen Ergebnis.
val list1 = List(2,3,4) val list2 = 1 :: list1 println(list1) println(list2)
Die Funktion :: eignet sich auch dazu einzelne Elemente
zu einer Liste zu verbinden. Das nachfolgende Skript zeigt exemplarisch
diese Vorgehensweise.
val list1 = 1 :: 2 :: 3 :: 4 :: Nil println(list1)
Die Ausführung dieses Skriptes führt zu folgender Ausgabe:
List(1, 2, 3, 4)
Da die Funktion :: in der Klasse List definiert
ist, muss als letztes Element ein List Objekt angegeben werden,
worauf die Funktion :: aufgerufen wird. In unserem Beispiel
ist dies Nil, was einer leeren List entspricht.
:::
def ::: (prefix: List[A]) : List[A] def ::: [B >: A] (prefix: List[B]) : List[B]
Die Funktion ::: verbindet zwei Listen zu einer neuen List. Die Ergebnisliste
beginnt dabei mit den Elementen, die als Argument der Funktion übergeben wurde, gefolgt
von den Elementen der Liste auf der die Funktion ::: aufgerufen wurde.
Im nachfolgendem Skript werden zunächst zwei Listen den Variablen
list1 und list2 zugewiesen. Anschließend
wird eine neue Liste mit dem Inhalt von list1 und list2
erstellt und der Variablen list3 zugewiesen.
val list1 = List(1,2,3) val list2 = List(4,5,6) val list3 = list2.:::(list1) println(list1) println(list2) println(list3)
Die Ausführung des Skriptes führt zu folgender Ausgabe:
List(1, 2, 3) List(4, 5, 6) List(1, 2, 3, 4, 5, 6)
Die Verwendung der Funktion ::: in der Schreibweise mit Punkt und Klammern
wird man in der Praxis weniger häufig antreffen. Geläufiger ist die Operator - Schreibweise.
Da die Funktion mit einem Doppelpunkt endet, wird die Funktion auf den rechten Operanden
ausgeführt. Dies erhöht deutlich die Lesbarkeit, da die Elemente des linken
Operanden vor den Elementen des rechten Operanden im Ergebnis erscheinen.
Das nachfolgende Beispiel entspricht dem obigem Beispiel, mit Ausnahme, das hier die Operator-Schreibweise angewendet wird.
val list1 = List(1,2,3) val list2 = List(4,5,6) val list3 = list1 ::: list2 println(list1) println(list2) println(list3)
apply
def apply(n: Int): A
Die Funktion apply(n: Int): A liefert das Element, welches sich an der zu übergebenden Stelle befindet.
Im nachfolgenden Beispiel erzeugen wir eine List mit dem Namen
theList. Anschließend legen wir den Inhalt der List
in der Variablen aValue1 ab. Die die Angabe des Methoden Namens
apply optional ist können wir Angabe des Namens apply
verzichten, was wir bei der Variablendefinition für aValue2
anwenden. Zum Abschluss geben wir den Inhalt der Variablen auf der Systemausgabe aus.
object MyApply1 {
def main(args: Array[String]) {
val theList = List(3,7,2,0,5)
val aValue1 = theList.apply(2)
val aValue2 = theList(3)
println(aValue1)
println(aValue2)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
2 0
contains
def contains (elem: Any): Boolean
Die Funktion contains überprüft ob ein übergebenes Element in der
Liste enthalten ist. Nachfolgend eine beispielhafte Anwendung:
object ContainsIt {
def main(args: Array[String]){
val myList = List("123","abc","456","def")
println(myList contains "1234")
println(myList contains "abc")
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
false true
count
Ermittelt die Anzahl Elemente, die eine definierte Bedinung erfüllen. Die zu erfüllende Bedingung
wird dabei als Funktion an count übergeben.
object ListCountDemo {
def main(args: Array[String]): Unit = {
val myList = List(1,2,3,4,5,6,7,8,9,10)
val oddNumbers1 = myList.count((p: Int) => p % 2 != 0)
val oddNumbers2 = myList.count(_ % 2 != 0)
println("odd-numbered1 = "+oddNumbers1)
println("odd-numbered2 = "+oddNumbers2)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
odd-numbered1 = 5
odd-numbered2 = 5
drop
def drop(n: Int): List[A]
Die Funktion drop(n: Int) liefert eine neue List bestehend
aus den Elementen der List auf der drop aufgerufen
wurde ohne die ersten n Elemente.
object DropDemo {
def main(args: Array[String]): Unit = {
val list1 = List(1,3,5,7,9,11)
val list2 = list1.drop(2)
println(list1)
println(list2)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
List(1, 3, 5, 7, 9, 11)
List(5, 7, 9, 11)
dropRight
dropRight(n: Int): List[A]
Die Funktion dropRight(n: Int) liefert eine neue List bestehend aus
den Elementen der List auf der dropRight aufgerufen wurde
ohne die n letzen Elemente.
object DropRightDemo {
def main(args: Array[String]): Unit = {
val list1 = List(1,3,5,7,9,11)
val list2 = list1.dropRight(2)
println(list1)
println(list2)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
List(1, 3, 5, 7, 9, 11)
List(1, 3, 5, 7)
equals
def equals(that: Any): Boolean
Die Funktion equals überprüft ob die beiden
beteiligten Objekte gleich sind. Auch wenn hashCode im
folgenden Beispiel nicht aufgerufen wird gilt: Wenn man in einer Klasse equals
überschreibt, sollte auch die Funktion hashCode überschrieben werden.
Die Funktion hashCode kommt zum Beispiel bei der Erzeugung eines
Set zum Einsatz.
object MyEquals {
def main(args:Array[String]){
val valueA = new AClass(42)
val valueB = new AClass(42)
val valueC = new AClass(41)
println(valueA == valueB)
println(valueA == valueC)
}
}
class AClass(val aValue: Int){
override def equals(that: Any): Boolean = that match {
case that: AClass => that.aValue == aValue
case _ => false
}
override def hashCode = 41 + aValue
}
Die Ausführung des Programmes führt zu folgender Ausgabe auf der Systemausgabe:
true false
exists
def exists (p: (A) => Boolean): Boolean
Die Funktion exists überprüft, ob zumindest ein Element der Liste die Anforderung der übergebenen Funktion entspricht.
Im nachfolgenden Beispiel werden zwei List Objekte mit Int Werten erzeugt. Die Variable myFunction ist
einer Funktion zugeordnet, die als Parameter einen Int-Wert erwartet und als Ergebnis true liefert, wenn
das Argument durch 2 ohne Rest teilbar ist. Diese Funktion übergeben wir der Funktion exists der zuvor erzeugten Listen.
Sollte ein Argument der Liste durch 2 ohne Rest teilbar sein, ist das Ergebnis von exists true andernfalls ist das Ergebnis
false.
object ListExists {
def main(args: Array[String]) {
val list1 = List(1,2,4,5,7)
val list2 = List(1,3,5,7)
val myFunction = (x: Int) => x % 2 == 0
println(list1.exists(myFunction))
println(list2.exists(myFunction))
}
}
Die Ausführung des Programmes führt zu folgender Ausgabe auf der Systemausgabe:
true false
filter
def filter (p: (A) => Boolean) : List[A]
Erzeugt eine Liste bestehend aus Elementen der Ausgangsliste, die eine
zu definierende Bedingung erfüllen. Die zu erfüllende Bedingung
wird der Funktion filter über eine Funktion mitgeteilt.
Zur Demonstration der Funktion filter definieren wir
eine List mit Elementen des Datentyps Int:
scala> val list1 = List(1,33,26,146,32,55,26,217,24,326) list1: List[Int] = List(1, 33, 26, 146, 32, 55, 26, 217, 24, 326)
Nun erzeugen wir eine neue List über die Funktion filter
mit allem Elementen aus list1 die größer 50 sind.
Um dies zu erreichen, definieren wir beim Aufruf der Funktion filter
ein Funktionsliteral innerhalb der Klammern der Funktion.
scala> val list2 = list1.filter((x: Int) => x > 50) list2: List[Int] = List(146, 55, 217, 326)
Da die List nur aus Int Werten besteht, kann der Scala Compiler
den Typ der Variablen über Typableitung (type inference) bestimmen. Daher
muss der Typ der Variablen x in der Funktion nicht angegeben werden.
scala> val list3 = list1.filter(x => x < 30) list3: List[Int] = List(1, 26, 26, 24)
Da filter immer ein Element der Filter-Funktion übergibt,
kann die Schreibweise der Funktion weiter vereinfacht werden und auf den
übergebenen Parameter mit dem Unterstrich zugegriffen werden.
scala> val list4 = list1.filter(_ > 100) list4: List[Int] = List(146, 217, 326)
filterNot
def filterNot(p: (A) ⇒ Boolean): List[A]
Die Funktion filterNot erzeugt eine List, welche alle
Elemente der Ausgangs-List enthält, die der zu übergebenden
Bedingung nicht entsprechen.
Im nachfolgenden Beispiel wird eine List erzeugt, die alle Elemente
der Ausgangs-List enthält, die nicht gerade sind.
object FilterNotDemo {
def main(args: Array[String]): Unit = {
val aList: List[Int] = List(2,7,3,4,7,2,6)
val bList = aList.filterNot((x: Int) => x % 2 == 0)
bList.foreach(println)
}
}
Die Ausführung des Programms führt zur folgenden Ausgabe auf der Systemausgabe:
7 3 7
find
find(p: (A) => Boolean): Option[A]
Die Funktion find findet das erste Element in der List auf
der das übergebene Argument true liefert.
Das Ergebnis wird in einem Option - Typ zurückgeliefert. Im Falle,
dass das Element in der List enthalten ist wird ein Some
mit dem entsprechenden Wert zurückgeliefert. Im entgegengesetzten Fall
wird ein None zurückgeliefert.
Nachfolgend ein Beispiel:
object FindInList {
def main(args: Array[String]): Unit = {
val myList = List(5,2,86,3,55,7,86)
val firstFindResult = myList.find(_ > 40)
val secondFindResult = myList.find( _ < 0)
println(firstFindResult)
println(secondFindResult)
println(firstFindResult.get)
}
}
Die Ausführung dieses Programmes führt zu folgender Ausgabe auf der Systemausgabe:
Some(86)
None
86
foldLeft
def foldLeft[B](z: B)(f: (B, A) ⇒ B): B
Die Funktion foldLeft wendet eine Binärfunktion nacheinander
auf einen Startwert gefolgt von allen Elementen der List an.
Das Ergebnis der Binärfunktion ist (mit Ausnahme des Startwertes) das
erste Element der Binärfunktion bei der nächsten Auswertung.
Das Ergebnis von foldLeft ist die Auswertung des letzten
Elementes der List. Wie der Name foldLeft bereits
andeutet, wird die List von Links nach Rechts durchlaufen
(beginnt also mit der Auswertung von 1 und endet mit der Auswertung von 11).
Nachfolgend ein Beispiel:
object FoldLeftDemo {
def main(args: Array[String]): Unit = {
val myList = List(1,3,5,7,9,11)
def myBinFunction(a: Int, b: Int): Int = a - b
val myResult: Int = myList.foldLeft(0)(myBinFunction)
println(myResult)
}
}
Die Ausführung des Programms führt zur Ausgabe von -36 als Ergebnis
von foldLeft.
Die nachfolgenden Schritte zeigen den Weg von foldLeft um zum Ergebnis (-36)
zu gelangen.
0 - 1 = -1
-1 - 3 = -4
-4 - 5 = -9
-9 - 7 = -16
-16 - 9 = -25
-25 - 11 = -36
forall
def forall(p: (A) ⇒ Boolean): Boolean
Die Funktion forall überprüft, ob alle Elemente die übergebene Bedingung erfüllt.
object MyForAll {
def main(args:Array[String]){
val aList = List(1,34,5,2,4,56)
println(aList.forall(i => i <100))
println(aList.forall(_ < 50))
}
}
Die Ausführung dieses Programmes führt zu folgender Ausgabe auf der Systemausgabe:
true false
foreach
def foreach (f: (A) => Unit) : Unit def foreach [B] (f: (A) => B) : Unit
Die Funktion foreach iteriert über alle Elemente der Liste,
welche in einer zu übergebenen Funktion verarbeitet werden können.
Das nachfolgende Beispiel zeigt die Verwendung von foreach
mit einem Funktionsliteral, welches die enthaltenen Elemente auf der
Systemausgabe ausgibt.
object MyListTest {
def main(args: Array[String]) {
val myList = List(1,6,3,9,4)
myList.foreach(i => println(i))
}
}
Die Ausführung dieses Programmes führt zu folgender Ausgabe auf der Systemausgabe:
1 6 3 9 4
head
def head : A
Die Funktion head liefert das erste Element einer Liste.
Der nachfolgende Quelltext zeigt beispielhaft die Verwendung der Funktion head.
object MyListHeadTest {
def main(args: Array[String]) {
val myList = List(4,3,2,1)
val headOfList = myList.head
println(headOfList)
}
}
Als Ergebnis des Programmablaufs wird der Int-Wert 4 auf
der Systemausgabe ausgegeben.
last
Die Funktion last liefert das letzte Element der zugehöigen List.
object LastListElement {
def main(args: Array[String]): Unit = {
val theList = List("2","7","1","3","7","3")
println(theList.last)
}
}
Als Ergebnis des Programmablaufs wird der String '3' auf
der Systemausgabe ausgegeben.
length
def length: Int
Die Funktion length der Klasse List liefert die Anzahl
der in der List enthaltenen Elemente. Im nachfolgenden Beispiel erzeugen
wir zunächst eine List mit Int Werten und
geben im Anschluss die Anzahl der Elemente aus.
Als Ergebnis erhalten wir die Ausgabe 5 auf der Systemausgabe.
object ListLengthDemo {
def main(aregs: Array[String]): Unit = {
val myList = List(4,7,2,7,6)
println(myList.length)
}
}
map
def map [B] (f: (A) ? B): List[B] def map [B, That] (f: (A) ? B)(implicit bf: CanBuildFrom[List[A], B, That]): That
map erzeugt eine neue Liste durch Anwendung einer Funktion auf alle Elemente der Ausgangsliste.
Im nachfolgenden Beispiel wird auf jedes Element der Ausgangsliste eine Funktion angewendet,
welche jeden Wert mit 2 multipliziert. Das jeweilige Listenelement wird in der Funktion durch den
Unterstrich repräsentiert.
object TheMapFunction {
def main(args: Array[String]) {
val list1 = List(1,2,3,4)
val list2 = list1 map (_ * 2)
println(list1)
println(list2)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
List(1, 2, 3, 4) List(2, 4, 6, 8)
reduceLeft
reduceLeft [B >: A] (f: (B, A) => B) : B
reduceLeft iteriert paarweise über die Liste von der linken Seite aus
und wertet mit diesen die übergebene Funktion aus. Die Iteration beginnt mit den ersten beiden
Elementen der Liste. Das Ergebnis der Auswertung und das
nächte Element der Liste werden im Anschluss in gleicher Weise ausgewertet.
Diese Iteration wird fortgesetzt bis das Ende der Liste erreicht ist. Das Ergebnis
von reduceLeft ist das Ergebnis der letzten Auswertung.
Nachfolgend beispielhaft die Anwendung von reduceLeft
object ReduceLeft1{
def main(args: Array[String]) {
val myList = List(1,4,5,8,5,2,5)
myList.reduceLeft{(a,b) =>
if (a > b) {
println("true "+a+" "+b)
a * 2
}
else {
println("false "+a+" "+b)
b
}
}
}
}
Die Ausführung des Programmes führt zu folgender Ausgabe:
false 1 4 false 4 5 false 5 8 true 8 5 true 16 2 true 32 5
object ReduceLeft2 {
def main(args: Array[String]) {
val myList = List(1,4,5,8,5,2,5)
println(myList.reduceLeft((a,b) => test(a,b)))
}
def test(v1: Int, v2: Int) = if (v2 > v1) v2 else v1
}
Die Ausführung des Programmes führt zum Ergebnis 8.
reverse
def reverse : List[A]
Die Funktion reverse: List[A] liefert eine List mit allen Elementen der Ursprungsliste,
wobei die Elemente in umgekehrter Reihenfolge enthalten sind.
object ListReverse {
def main(args: Array[String]) {
val myList = List(1,2,3,4)
println(myList)
val reverseList = myList.reverse
println(reverseList)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
List(1, 2, 3, 4) List(4, 3, 2, 1)
size
def size : Int
Die Funktion size der Klasse List liefert die Anzahl Elemente, die in der List enthalten sind.
Das nachfolgende Beispiel erzeugt zunächst eine Liste mit 5 Elementen. In der nachfolgenden Systemausgabe wird
die Anzahl der Elemente ausgegeben.
object ListSize extends Application{
val myList = List(1,2,3,4,5)
println(myList.size)
}
tail
def tail : List[A]
tail liefert eine neue List, ohne das erste Element der List
auf dem tail aufgerufen wurde. Das nachfolgende Skript zeigt beispielhaft die Anwendung
von tail.
val list1 = List(1,2,3,4,5,6) val list2 = list1.tail println(list1) println(list2)
Der Ablauf des Skriptes führt zu folgender Ausgabe auf der Systemausgabe:
List(1, 2, 3, 4, 5, 6) List(2, 3, 4, 5, 6)
toSet
def toSet[B >: A]: Set[B]
Die Funktion toSet liefert ein Set auf Basis der List
auf der toSetaufgerufen wurde. Doppelte Elemente in der List
werden dabei entfernt.
import scala.collection.immutable.HashSet
object ListToSetDemo {
def main(args: Array[String]): Unit = {
val aList = List(3,6,8,5,7,3,6,2,6,5,1)
val aSet = aList.toSet
println(aList)
println(aSet)
}
}
Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:
List(3, 6, 8, 5, 7, 3, 6, 2, 6, 5, 1) Set(5, 1, 6, 2, 7, 3, 8)