文章目录
- [1.3 Scala的数据结构](#1.3 Scala的数据结构)
1.3 Scala的数据结构
对于每一门编程语言来说，数组（Array）都是重要的数据结构之一，主要用来存储数据类型相同的元素。Scala中的数组分为定长数组和变长数组，定义定长数组，需要使用new关键字，而定义变长数组时，则需要导包import scala.collection.mutable.ArrayBuffer。
1.3.1 数组
数组（Array）主要用来存储数据类型是每个人元素。
-
数组定义与使用
Scala中的数组分为定长数组和变长数组，这两种数组的定义方式如下：
-
定义定长数组
New Array[T] (数组长度) //定义定长数组
-
定义变长数组
ArrayBufferT //定义变长数组
注：定义定长数组，需要使用new关键字，而定义变长数组时，则需要导包import scala.collection.mutable.ArrayBuffer。
下面，通过一个例子来演示Scala数组简单使用，具体代码如下所示。
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)
}
}
数组的遍历
Scala中，如果想要获取数组中的每一个元素，则需要将数组进行遍历操作。代码如下：
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)
}
}
数组转换
数组转换就是通过yield关键字将原始的数组进行转换，会产生一个新的数组，然而原始的数组保持不变。定义一个数组，实现将偶数取出乘以10后生成一个新的数组，具体代码如下所示：
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 元组
Scala的元组是对多个不同类型对象的一种简单封装，它将不同的值用小括号括起来，并用逗号作分隔，即表示元组。
创建元组
创建元组的语法格式如下：
val tuple=(元素,元素...)
下面，通过简单的例子进行演示创建元组，例如：创建一个包含String类型、Double类型以及Int类型的元组，具体代码如下：
scala> val tuple = ("itcast",3.14,65535)
tuple: (String, Double, Int) = (itcast,3.14,65535)
获取元组中的值
在Scala中，获取元组中的值是通过下划线加脚标（例如：tuple._1，tuple._2）来获取的，元组中的元素脚标是从1开始的。代码如下：
scala> tuple._1 # 获取第一个值
res0: String = itcast
scala> tuple._2 # 获取第一个值
res1: Double = 3.14
拉链操作
在Scala的元组中，可以通过使用"zip"命令将多个值绑定在一起。例如，定义两个数组，分别是score和names，将这两个数组捆绑在一起，具体代码如下：
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))
注：当两个数组个数不等时，会自动适配较短长度，多余元素无相应匹配元素会被自动抛弃。
1.3.3 集合
在Scala中，集合有三大类： List、Set以及Map，所有的集合都扩展自Iterable特质。
Scala 集合分为可变的（mutable）和不可变（immutable）的集合。其中，可变集合可以在适当的地方被更新或扩展，意味着可以对集合进行修改、添加、移除元素；不可变集合类，相比之下，初始化后就永远不会改变。
List
在Scala中，List列表和数组类似，列表的所有元素都具有相同类型。然而，列表与数组不同的是，列表是不可变的。
定义不同类型列表List，具体代码如下：
// 字符串
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)
)
在Scala中，可以使用"Nil"和"：："操作符来定义列表。代码如下：
// 字符串
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也提供了很多操作List的方法，如下表所示。
示例代码如下：
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"))
}
}
Set
在Scala中，Set是没有重复对象的集合，所有元素都是唯一的。默认情况下，Scala 使用不可变Set集合，若想使用可变的Set集合，则需要引入 scala.collection.mutable.Set 包。
定义Set集合的语法格式如下：
val set: Set[Int] = Set(1,2,3,4,5)
Scala提供了很多操作Set集合的方法。接下来，我们列举一些操作Set集合的常见方法，具体如下表所示。
具体代码如下所示：
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"))
}
}
Map
在Scala中，Map是一种可迭代的键值对（key/value）结构，并且键是唯一的，值不一定是唯一的，所有的值都是通过键来获取的。Map中所有元素的键与值都存在一种对应关系，这种关系即为映射。Map有两种类型，可变集合与不可变集合，默认是不可变Map。若需要使用可变的Map集合，则需要引入 import scala.collection.mutable.Map 类。
定义Map集合的语法格式如下：
var A:Map[Char,Int] = Map(键 -> 值,键 -> 值...) //Map键值对，键为Char，值为Int
Scala也提供了很多操作Map集合的方法。接下来，我们列举一些操作Map集合的常见方法，具体如下表所示：
示例代码如下所示：
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)
}
}
转载自:https://blog.csdn.net/u014727709/article/details/131679759
欢迎start，欢迎评论，欢迎指正