Artikelverzeichnis
1.3 Scala-Datenstrukturen
Für jede Programmiersprache ist Array (Array) eine der wichtigen Datenstrukturen, die hauptsächlich zum Speichern von Elementen desselben Datentyps verwendet wird. Arrays in Scala sind in Arrays mit fester Länge und Arrays mit variabler Länge unterteilt. Um ein Array mit fester Länge zu definieren, müssen Sie das Schlüsselwort new verwenden. Wenn Sie ein Array mit variabler Länge definieren, müssen Sie das Paket import scala.collection importieren .mutable.ArrayBuffer.
1.3.1 Arrays
Array (Array) wird hauptsächlich zum Speichern des Datentyps jedes Elements verwendet.
-
Array-Definition und -Verwendung
Arrays in Scala werden in Arrays mit fester Länge und Arrays mit variabler Länge unterteilt. Diese beiden Arrays sind wie folgt definiert: -
Definieren Sie ein Array mit fester Länge.
New Array[T] (Array-Länge) // Definieren Sie ein Array mit fester Länge -
Array mit variabler Länge definieren
ArrayBuffer T //Array mit variabler Länge definieren
Hinweis: Um ein Array mit fester Länge zu definieren, müssen Sie das Schlüsselwort new verwenden. Um ein Array mit variabler Länge zu definieren, müssen Sie das Paket import scala.collection.mutable.ArrayBuffer importieren.
Im Folgenden wird anhand eines Beispiels die einfache Verwendung von Scala-Arrays demonstriert. Der spezifische Code lautet wie folgt.
package cn.itcast.scala
import scala.collection.mutable.ArrayBuffer
object Ch01_ArrayDemo {
def main(args: Array[String]): Unit = {
//定义定长数组：定义长度为8的定长数组，数组中的每个元素初始化为0
val arr1 = new Array[Int](8)
//打印数组,内容是数组的hashcode值
println(arr1)
//定义变长数组（数组缓冲），需要导入包：import scala.collection.mutable.ArrayBuffer
val arr2 = ArrayBuffer[Int]()
//向变长数组中追加元素
arr2 += 1
//打印变长数组
println(arr2)
//向变长数组中追加多个元素
arr2 += (2,3,4,5)
println(arr2)
//追加一个定长数组
arr2 ++= Array(6,7)
println(arr2)
//追加一个变长数组(数组缓冲)
arr2 ++= ArrayBuffer(8,9)
println(arr2)
//在变长数组的某个位置插入元素
arr2.insert(0,-1,0)
println(arr2)
//删除数组的某个元素
arr2.remove(0)
println(arr2)
}
}
Array-Durchquerung
Wenn Sie in Scala jedes Element im Array abrufen möchten, müssen Sie das Array durchlaufen. Code wie folgt anzeigen:
package cn.itcast.scala
object Ch02_ArrayTraversal {
def main(args: Array[String]): Unit = {
//定义定长数组
//val array = new Array[Int](8) //方式1
val myArr = Array(1.9, 2.9, 3.4, 3.5) //方式2
//打印输出数组中的所有元素
for(x<-myArr){
print(x+" ")
}
println()
//计算数组中所有元素的和
var total = 0.0
for(i <- 0 to (myArr.length-1)){
total += myArr(i)
}
println("总和为："+total)
//查找数组中的最大值
var max = myArr(0)
for(i <- 1 to (myArr.length-1)){
if(max < myArr(i)){
max = myArr(i)
}
}
println("最大值为："+max)
}
}
Array-Konvertierung
Bei der Array-Konvertierung wird das ursprüngliche Array über das Schlüsselwort yield konvertiert. Es wird ein neues Array generiert, das ursprüngliche Array bleibt jedoch unverändert. Definieren Sie ein Array, um ein neues Array zu generieren, nachdem gerade Zahlen herausgenommen und mit 10 multipliziert wurden. Der spezifische Code lautet wie folgt:
package cn.itcast.scala
object Ch03_ArrayYieldTest {
def main(args: Array[String]): Unit = {
//定义一个数组
var arr = Array(1,2,3,4,5,6,7,8,9)
//将偶数取出乘以10后再生成一个新的数组
val newArr = for (e <- arr if e%2 == 0) yield e * 10
println(newArr.toBuffer) //将定长数组转为变长数组
}
}
1.3.2 Tupel
Das Tupel von Scala ist eine einfache Kapselung mehrerer Objekte unterschiedlichen Typs. Es schließt verschiedene Werte in Klammern ein und trennt sie durch Kommas, was ein Tupel bedeutet.
Tupel erstellen
Die Syntax zum Erstellen eines Tupels lautet wie folgt:
val tuple=(元素,元素...)
Nachfolgend wird ein einfaches Beispiel verwendet, um die Erstellung von Tupeln zu demonstrieren. Beispiel: Um ein Tupel mit den Typen String, Double und Int zu erstellen, lautet der spezifische Code wie folgt:
scala> val tuple = ("itcast",3.14,65535)
tuple: (String, Double, Int) = (itcast,3.14,65535)
Rufen Sie den Wert im Tupel ab
In Scala wird der Wert im Tupel durch Unterstrich und Index ermittelt (zum Beispiel: tuple._1, tuple._2), und der Index des Elements im Tupel beginnt bei 1. Code wie folgt anzeigen:
scala> tuple._1 # 获取第一个值
res0: String = itcast
scala> tuple._2 # 获取第一个值
res1: Double = 3.14
Zip-Betrieb
In Scalas Tupeln können mehrere Werte mithilfe des Befehls „zip“ zusammengebunden werden. Definieren Sie beispielsweise zwei Arrays, nämlich Punktzahl und Namen, und bündeln Sie diese beiden Arrays. Der spezifische Code lautet wie folgt:
scala> val scores = Array(88,95,80)
scores: Array[Int] = Array(88, 95, 80)
scala> val names =Array("zhangsan","lisi","wangwu")
names: Array[String] = Array(zhangsan, lisi, wangwu)
scala> names.zip(scores)
res2: Array[(String, Int)] = Array((zhangsan,88), (lisi,95), (wangwu,80))
Hinweis: Wenn die Anzahl der beiden Arrays nicht gleich ist, wird die kürzere Länge automatisch angepasst und die redundanten Elemente ohne entsprechende übereinstimmende Elemente werden automatisch verworfen.
1.3.3 Sammlungen
In Scala gibt es drei Arten von Sammlungen: List, Set und Map, die alle das Iterable-Merkmal erweitern.
Scala-Sammlungen sind in veränderliche und unveränderliche Sammlungen unterteilt. Unter anderem kann die veränderliche Sammlung vor Ort aktualisiert oder erweitert werden, was bedeutet, dass die Sammlung geändert, Elemente hinzugefügt und entfernt werden kann; die unveränderliche Sammlungsklasse hingegen wird sich nach der Initialisierung nie ändern.
Aufführen
In Scala ähnelt eine Liste einem Array darin, dass alle Elemente einer Liste denselben Typ haben. Im Gegensatz zu Arrays sind Listen jedoch unveränderlich.
Definieren Sie verschiedene Listentypen. Der spezifische Code lautet wie folgt:
// 字符串
val fruit: List[String] =List("apples","oranges","pears")
// 整型
val nums: List[Int] = List(1, 2, 3, 4)
// 空
val empty: List[Nothing] = List()
// 二维列表
val dim: List[List[Int]] =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1)
)
In Scala können Listen mit den Operatoren „Nil“ und „::“ definiert werden. Code wie folgt anzeigen:
// 字符串
val fruit = "apples":: ("oranges":: ("pears" :: Nil))
// 整型
val nums = 1 :: (2 :: (3 :: ( 4 :: Nil)))
// 空列表
val empty = Nil
// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
(0 :: (1 :: (0 :: Nil))) ::
(0 :: (0 :: (1 :: Nil))) :: Nil
Scala bietet auch viele Methoden zum Bearbeiten von Listen, wie in der folgenden Tabelle gezeigt.
Der Beispielcode lautet wie folgt:
package cn.itcast.scala
object Ch04_ListTest {
def main(args: Array[String]): Unit = {
//定义List集合
//val fruit:List[String] = List("apples","oranges","pears")
val fruit = "apples"::("oranges"::("pears"::Nil))
val nums = Nil
println("Head of fruit:" + fruit.head)
println("Tail of fruit:" + fruit.tail)
println("check if fruit is empty:"+fruit.isEmpty)
println("check if nums is empty:"+nums.isEmpty)
println("Take of fruit:"+fruit.take(2))
println("contains of fruit oranages:"+fruit.contains("oranges"))
}
}
Satz
In Scala ist ein Set eine Sammlung ohne doppelte Objekte und alle Elemente sind eindeutig. Standardmäßig verwendet Scala eine unveränderliche Set-Sammlung. Wenn Sie eine veränderbare Set-Sammlung verwenden möchten, müssen Sie das Paket scala.collection.mutable.Set einführen.
Die Syntax zum Definieren einer Set-Sammlung lautet wie folgt:
val set: Set[Int] = Set(1,2,3,4,5)
Scala bietet viele Methoden zum Bearbeiten von Set-Sammlungen. Als Nächstes listen wir einige gängige Methoden zum Betreiben von Set-Sammlungen auf, wie in der folgenden Tabelle dargestellt.
Der spezifische Code lautet wie folgt:
package cn.itcast.scala
object Ch05_SetTest {
def main(args: Array[String]): Unit = {
//定义Set集合
val site = Set("Itcast","Google","Baidu")
val nums:Set[Int] = Set()
println("第一个网站是："+site.head)
println("最后一个网站是："+site.tail)
println("site集合是否为空："+site.isEmpty)
println("nums集合是否为空："+nums.isEmpty)
println("查看site集合的前两个网站："+nums.take(2))
println("site集合中是不包含网站Google："+site.contains("Google"))
}
}
Karte
In Scala ist Map eine iterierbare Schlüssel-Wert-Paar-Struktur (Schlüssel/Wert), und der Schlüssel ist eindeutig, aber der Wert ist nicht unbedingt eindeutig. Alle Werte werden über den Schlüssel erhalten. Es gibt eine entsprechende Beziehung zwischen dem Schlüssel und dem Wert aller Elemente in der Karte, und diese Beziehung ist die Zuordnung. Es gibt zwei Arten von Karten: veränderliche Sammlungen und unveränderliche Sammlungen. Der Standardwert ist unveränderliche Karten. Wenn Sie eine veränderbare Kartensammlung verwenden müssen, müssen Sie die Importklasse scala.collection.mutable.Map einführen.
Die Syntax zum Definieren einer Kartensammlung lautet wie folgt:
var A:Map[Char,Int] = Map(键 -> 值,键 -> 值...) //Map键值对，键为Char，值为Int
Scala bietet auch viele Methoden zum Bearbeiten von Kartensammlungen. Als Nächstes listen wir einige gängige Methoden zum Betreiben von Kartensammlungen auf, wie in der folgenden Tabelle dargestellt:
Der Beispielcode lautet wie folgt:
package cn.itcast.scala
object Ch06_MapTest {
def main(args: Array[String]): Unit = {
//定义Map集合
val colors = Map("red"-> "#FF0000",
"azure"-> "#F0FFFF",
"peru"-> "#CD853F")
val peruColor = if(colors.contains("peru")) colors("peru") else 0
val azureColor = colors.getOrElse("azure",0)
println("获取colors中键为red的值："+colors("red"))
println("获取colors中所有的键："+colors.keys)
println("获取colors中所有的值："+colors.values)
println("检测colors是否为空："+colors.isEmpty)
println("判断colors中是否包含键peru，包含则返回对应的值，否则返回0："+peruColor)
println("判断colors中是否包含键azure，包含则返回对应的值，否则返回0："+azureColor)
}
}
Nachdruck von: https://blog.csdn.net/u014727709/article/details/131679759
Willkommen zum Starten, willkommen zum Kommentieren, willkommen zum Korrigieren