Scala Language
Tuples

Bemerkungen

Einen neuen Tupel erstellen

Ein Tupel ist eine heterogene Sammlung von zwei bis zweiundzwanzig Werten. Ein Tupel kann mit Klammern definiert werden. Für Tupel der Größe 2 (auch als "Paar" bezeichnet) gibt es eine Pfeilsyntax.

scala> val x = (1, "hello") 
x: (Int, String) = (1,hello)
scala> val y = 2 -> "world" 
y: (Int, String) = (2,world)
scala> val z = 3 → "foo"     //example of using U+2192 RIGHTWARD ARROW
z: (Int, String) = (3,foo)

x ist ein Tupel der Größe zwei. Um auf die Elemente eines Tupels ._1 , verwenden Sie ._1 bis ._22 . Mit x._1 können wir x._1 auf das erste Element des x Tupels zugreifen. x._2 greift auf das zweite Element zu. Eleganter können Sie Tupel-Extraktoren verwenden .

Die Pfeilsyntax zum Erstellen von Tupeln der Größe zwei wird hauptsächlich in Maps verwendet. Hierbei handelt es sich um Sammlungen von (key -> value) -paaren:

scala> val m = Map[Int, String](2 -> "world")
m: scala.collection.immutable.Map[Int,String] = Map(2 -> world)

scala> m + x
res0: scala.collection.immutable.Map[Int,String] = Map(2 -> world, 1 -> hello)

scala> (m + x).toList
res1: List[(Int, String)] = List((2,world), (1,hello))

Die Syntax für das Paar in der Map ist die Pfeilsyntax. Damit wird klar, dass 1 der Schlüssel und a der mit diesem Schlüssel verknüpfte Wert ist.

Tupel in Sammlungen

Tupel werden häufig in Sammlungen verwendet, müssen jedoch auf bestimmte Weise gehandhabt werden. Geben Sie beispielsweise die folgende Liste von Tupeln an:

scala> val l = List(1 -> 2, 2 -> 3, 3 -> 4)
l: List[(Int, Int)] = List((1,2), (2,3), (3,4))

Es kann naheliegend sein, die Elemente durch implizites Entpacken des Tupels zusammenzufügen:

scala> l.map((e1: Int, e2: Int) => e1 + e2)

Dies führt jedoch zu folgendem Fehler:

<console>:9: error: type mismatch;
 found   : (Int, Int) => Int
 required: ((Int, Int)) => ?
              l.map((e1: Int, e2: Int) => e1 + e2)

Scala kann die Tupel auf diese Weise nicht implizit auspacken. Wir haben zwei Möglichkeiten, diese Karte zu reparieren. Die erste besteht darin, die Positionszugriffe _1 und _2 :

scala> l.map(e => e._1 + e._2)
res1: List[Int] = List(3, 5, 7)

Die andere Option ist die Verwendung einer case Anweisung zum Entpacken der Tupel mithilfe von Mustervergleich:

scala> l.map{ case (e1: Int, e2: Int) => e1 + e2}
res2: List[Int] = List(3, 5, 7)

Diese Einschränkungen gelten für alle Funktionen höherer Ordnung, die auf eine Sammlung von Tupeln angewendet werden.