对于每一门编程语言来说,数组(Array)都是重要的数据结构之一,主要用来存储数据类型相同的元素。Scala中的数组分为定长数组和变长数组,定义定长数组,需要使用new关键字,而定义变长数组时,则需要导包import scala.collection.mutable.ArrayBuffer。
数组(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) //将定长数组转为变长数组
}
}
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))
注:当两个数组个数不等时,会自动适配较短长度,多余元素无相应匹配元素会被自动抛弃。
在Scala中,集合有三大类: List、Set以及Map,所有的集合都扩展自Iterable特质。
Scala 集合分为可变的(mutable)和不可变(immutable)的集合。其中,可变集合可以在适当的地方被更新或扩展,意味着可以对集合进行修改、添加、移除元素;不可变集合类,相比之下,初始化后就永远不会改变。
在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"))
}
}
在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"))
}
}
在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,欢迎评论,欢迎指正