day04-scala学习之数组、映射(Map)、元组(Tuple)

最新推荐文章于 2023-03-16 11:46:06 发布

原创最新推荐文章于 2023-03-16 11:46:06 发布

· 343 阅读

1 ·

版权

文章标签：

#scala #大数据

bigdata 专栏收录该内容

16 篇文章

订阅专栏

这篇博客介绍了Scala中的数组，包括定长和变长数组的概念及操作，如Array与ArrayBuffer的使用，以及数组遍历的方法。接着讲解了映射(Map)的创建和示例，最后探讨了元组(Tuple)的特性，并展示了如何在Scala命令行中操作这些数据结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

day03(day03-scala学习之函数参数、Lazy(懒值)、异常处理)，我们学习了scala函数参数、Lzay(懒值)、异常处理，今天学习scala的数组、映射(Map)、元组(Tuple)。

scala数组

scala数组分为如下两种：

定长数组：使用关键字Array定义。
变长数组：使用关键字ArayBuffer定义。

定长数组

如下在scala的命令行模式下进行一些定长数组的试验

scala> val a = new Array[Int](4)
a: Array[Int] = Array(0, 0, 0, 0)

scala> val b = new Array[String](3)
b: Array[String] = Array(null, null, null)
#没有指定长度，但是指定的元素值，scala会自动推导元素个数及元素的数据类型
scala> val c = Array("Tom","Many","Lily")
c: Array[String] = Array(Tom, Many, Lily)
#如元素的数据类型不止一种，scala会把这个数组的数据类型定义为Any，如Array[Any]
scala> val d = Array("Tom","Many",2)
d: Array[Any] = Array(Tom, Many, 2)

scala>

变长数组

使用变长数组，需要导入mutable这个包,如下在scala的命令行模式下进行一些变长数组的试验。

#先导入mutable这个包
scala> import scala.collection.mutable._
import scala.collection.mutable._
#定义了名为a的变长数组，里面存放的是Int类型的元素
scala> val a = ArrayBuffer[Int]()
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
#向数组中添加 3 这个元素
scala> a += 3
res0: a.type = ArrayBuffer(3)
# 同时添加多个元素
scala> a += (2,5,9)
res1: a.type = ArrayBuffer(3, 2, 5, 9)

scala> a
res2: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(3, 2, 5, 9)
#去掉最后2个元素
scala> a.trimEnd(2)

scala> a
res4: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(3, 2)

scala>

数组遍历

数据的遍历，可以使用for循环、foreach等进行，如下是在scala命令行下进行的示例。

scala> val a = Array("Tom","Many","Lily")
a: Array[String] = Array(Tom, Many, Lily)
#使用for循环进行遍历
scala> for(s <- a ) println(s)
Tom
Many
Lily
#使用foreach进行遍历
scala> a.foreach(println)
Tom
Many
Lily

scala>

scala数组的常用操作

如下是在scala的命令行模式下进行的一些scala操作演示。


scala> val a = Array("Tom","Many","Lily")
a: Array[String] = Array(Tom, Many, Lily)

scala> for(s <- a ) println(s)
Tom
Many
Lily

scala> a.foreach(println)
Tom
Many
Lily

scala> val a = Array(1,3,4,8,12)
a: Array[Int] = Array(1, 3, 4, 8, 12)
#scala对数组提供了很多的操作函数，在命令行下定义好数组后，输入“数组名.”，然后按Tab键，就可以看到scala对这个数组提供的所有方法
scala> a.
++              count            hasDefiniteSize      maxBy               sameElements    toBuffer
.........由于篇幅所限，这里省略了很多方法........
corresponds     grouped          max                  runWith             toArray
#求最大值
scala> a.max
res7: Int = 12
#求最小值
scala> a.min
res8: Int = 1
#sortWith(以某种 规则 进行排序)
#完整的写法为：a.sortWith((a,b) => {if(a>b) true else false})
#(a,b) => {if(a>b) true else false} 是一个函数。匿名函数：没有名字  传入两个参数a b 返回值 bool。
#(a,b) => {if(a>b) true else false}  简写 _>_
#匿名函数作为sortWith的参数，属于高级函数(函数式编程),后面的学习会介绍
scala> a.sortWith(_>_)
res11: Array[Int] = Array(12, 8, 4, 3, 1)

scala> a.sortWith(_<_)
res12: Array[Int] = Array(1, 3, 4, 8, 12)

scala>

scala多维数组

和Java一样，通过数组的数组来实现，多维数组的定义方法有两种：

使用ofDim函数创建
定义一个一维数组，然后数组里面的数据类型是数组

下面在scala的命令行模式下进行一些多维数组的演示。

#定义一个固定长度(2行3列)的二维数组
scala> val a = Array.ofDim[Int](2,3)
a: Array[Array[Int]] = Array(Array(0, 0, 0), Array(0, 0, 0))
#把第2行，第1列的元素值设为12
scala> a(1)(0) = 12

scala> a
res14: Array[Array[Int]] = Array(Array(0, 0, 0), Array(12, 0, 0))
#一个维数组，其中每个元素是一个一维数组，这样最终构成一个多维数组
scala> val b = new Array[Array[Int]](10)
b: Array[Array[Int]] = Array(null, null, null, null, null, null, null, null, null, null)
#使用for循环给这个多维数组赋值
scala> for(i <- 0 until b.length)
     | b(i) = new Array[Int](i+1)

scala> b
res16: Array[Array[Int]] = Array(Array(0), Array(0, 0), Array(0, 0, 0), Array(0, 0, 0, 0), Array(0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0))

scala>

映射(Map)

映射就是Map集合，由一个(key,value)组成。
scala中的Map使用” ->”操作符用来创建
下面在scala的命令行模式下进行一些Map的演示。

#默认创建的是不可变Map
scala> val map1 = Map("Mary"->18,"Lily"->19,"Tom"->20)
map1: scala.collection.immutable.Map[String,Int] = Map(Mary -> 18, Lily -> 19, Tom -> 20)

#导入mutable包，再创建Map，这里创建的map2就是可变的
scala>  import  scala.collection.mutable._
import scala.collection.mutable._
scala> val map2 = Map("Mary"->18,"Lily"->19,"Tom"->20)
map2: scala.collection.mutable.Map[String,Int] = Map(Tom -> 20, Lily -> 19, Mary -> 18)

#获取Map中的值，有两种方式，直接获取、使用get函数
scala> map2("Tom")
res1: Int = 20
scala> map2.get("Tom")
res4: Option[Int] = Some(20)
#如果key不存在，直接获取的方式，会报异常
scala> map2("lily")
java.util.NoSuchElementException: key not found: lily
  at scala.collection.MapLike$class.default(MapLike.scala:228)
  at scala.collection.AbstractMap.default(Map.scala:59)
  at scala.collection.mutable.HashMap.apply(HashMap.scala:65)
  ... 32 elided
#如果key不存在，get函数获取，返回的是None
scala> map2.get("lily")
res3: Option[Int] = None

#更新Map中的值，注意：必须操作是可变映射
#map1是不可变的映射，所以出来如下的异常
scala> map1("Tom")=24
<console>:16: error: value update is not a member of scala.collection.immutable.Map[String,Int]
       map1("Tom")=24
       ^

scala> map2("Tom")=24
#映射的遍历，可以使用for循环、foreach来进行
scala> map2.foreach(println)
(Tom,24)
(Lily,19)
(Mary,18)

scala> for(s<-map2)println(s)
(Tom,24)
(Lily,19)
(Mary,18)
#基于元组创建Map，元组后面介绍
scala> val map6 = Map(("Tom",1),("Mary",2))
map6: scala.collection.mutable.Map[String,Int] = Map(Tom -> 1, Mary -> 2)

scala>

元组(Tuple)

Scala中的Tuple：是不同类型值的集合。
下面在scala的命令行模式下进行一些Tuple的演示。

#如下是创建Tuple的最直接也是最常用的方式。
scala> val t1 = (1,2,31,"hello")
t1: (Int, Int, Int, String) = (1,2,31,hello)
#如果使用Tuple关键字来定义Tuple，那么你存在多少个元素，Tuple后加上相应的数字。
#如下没有Tuple后没有加数字，报异常
scala> val t2 = Tuple(1,2,"hello")
<console>:14: error: not found: value Tuple
       val t2 = Tuple(1,2,"hello")
                ^
#如下Tuple后加数字，正常创建，3是表示元组中有三个元素。
scala> val t2 = Tuple3(1,2,"hello")
t2: (Int, Int, String) = (1,2,hello)
# scala中的元组下标是从1开始的，查看的时候使用"元组名._1"是查看元组的第1个元素的值。
scala> t2._1
res11: Int = 1

scala> t2._2
res12: Int = 2

scala> t2._3
res13: String = hello

scala>

#遍历Tuple，需要先生成一个迭代器。
scala> val t3 = t2.productIterator
t3: Iterator[Any] = non-empty iterator
scala> t3.foreach(println)
1
2
hello

scala>