Scala系列6:Scala中Array,BufferArray,元组,list,set,map等集合使用详解

      Scala中集合类的序列有:数组,元组,列表,Set集,Map映射,其中数组,列表,Set,Map又分为可变和不可变两种。下面就此详细展开介绍使用。

0.数组的使用详解

scala中数组的概念是和Java类似,可以用数组来存放一组数据。scala中,有两种数组,一种是定长数组,另一种是变长数组。

0.1 定长数组

定长数组指的是数组的长度是不允许改变的 。通过指定长度定义数组,语法格式如下:

  • val/var 变量名 = new Array[元素类型](数组长度) //方式1: 通过指定长度定义数组
  • val/var 变量名 = Array(元素1, 元素2, 元素3...) // 方式2:用元素直接初始化数组

尖叫提示:

  1. 在scala中,数组的泛型使用 [] 来指定
  2. 使用 () 来获取元素,角标从0开始。
//1.通过初始化定义数组: 数组定义包含jave、scala、python三个元素的数组
scala> val a = Array("java", "scala", "python")
a: Array[String] = Array(java, scala, python)
scala> a.length
res17: Int = 3

//注意,这种不同类型数据也可以创建到数组里,类型为Any。
scala> val  a4=Array("a","b",1)
a4: Array[Any] = Array(a, b, 1)

//2.通过指定长度定义数组,这种指定类型的数组,只能赋值同类型的数据。
scala> val a = new Array[Int](100)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
scala> a(0) = 110
scala> println(a(0))
110
//注意:这种指定类型的数组,只能赋值同类型的数据。
scala> a (1)=1
scala> a(1)
res13: Int = 1
scala> a(2)="1b"
<console>:16: error: type mismatch;
 found   : String("1b")
 required: Int
       a(2)="1b"
            ^

0.2 变长数组

变长数组指的是数组的长度是可变的,可以往数组中添加、删除元素

[1.语法格式]:

  1. val/var a = ArrayBuffer[元素类型]()   //方式1:创建空的ArrayBuffer变长数组
  2. val/var a = ArrayBuffer(元素1,元素2,元素3....) //方式2:创建带有初始元素的ArrayBuffer

[尖叫提示]
创建变长数组,需要提前导入ArrayBuffer类 import scala.collection.mutable.ArrayBuffer

scala> import scala.collection.mutable._
import scala.collection.mutable._

scala> val a = ArrayBuffer("hadoop", "spark", "flink")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)

scala> a += "flume"
res0: a.type = ArrayBuffer(hadoop, spark, flink, flume)

[2.变长数组的操作]

  • 添加/修改/删除元素
  • 使用 += 添加元素
  • 使用 -= 删除元素
  • 使用 ++= 追加一个数组到变长数组
// 1.定义变长数组
scala> val a = ArrayBuffer("hadoop", "spark", "flink")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)
//2. 追加一个元素
scala> a += "flume"
res10: a.type = ArrayBuffer(hadoop, spark, flink, flume)
// 3.删除一个元素
scala> a -= "hadoop"
res11: a.type = ArrayBuffer(spark, flink, flume)
// 4. 追加一个数组
scala> a ++= Array("hive", "sqoop")
res12: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)

0.3数组的其他操作(定长数组和变长数组)

  • 遍历数组方式1:使用 for表达式 直接遍历数组中的元素
  • 遍历数组方式2:使用 索引 遍历数组中的元素
  • 数组求和——sum方法
  • 数组求最大值——max方法
  • 数组求最小值——min方法
  • 数组排序——sorted方法
//1.使用for直接遍历数组元素
scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> for(i<-a) println(i)
1
2
3
4
5
//2.使用for表达式基于索引下标遍历,并打印数组的元素
scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> for(i <- 0 to a.length - 1) println(a(i))
1
2
3
4
5
scala> for(i <- 0 until a.length) println(a(i))
1
2
3
4
5
【尖叫提示】
0 until n——生成一系列的数字,包含0,不包含n,左闭右开
0 to n ——包含0,也包含n

//3.数组求和,要针对数值型,否则报错
scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> a.sum
res49: Int = 10

//4.求数组最大值
scala> val a = Array(4,1,2,4,10)
a: Array[Int] = Array(4, 1, 2, 4, 10)
scala> a.max
res50: Int = 10
//5.最小值
scala> val a = Array(4,1,2,4,10)
a: Array[Int] = Array(4, 1, 2, 4, 10)
scala> a.min
res51: Int = 1
//6.排序
scala> a.sorted
res53: Array[Int] = Array(1, 2, 4, 4, 10)
// 降序
scala> a.sorted.reverse
res56: Array[Int] = Array(10, 4, 4, 2, 1)

1.元组的使用详解

元组可以用来包含一组不同类型的值。例如:姓名,年龄,性别,出生年月。元组的元素是不可变的。

【1.语法格式】

  • val/var 元组 = (元素1, 元素2, 元素3....)    //使用括号来定义元组
  • val/var 元组 = 元素1-> 元素2   //使用‘’箭头’来定义元素(元组只有两个元素)
// 可以直接使用括号来定义一个元组
scala> val a = (1, "张三", 20, "北京市")
a: (Int, String, Int, String) = (1,张三,20,北京市)
//使用箭头,注意,这种元组只有两个元素
scala> val a = 1->5
a: (Int, Int) = (1,5)
scala> val z = "x"-> "y"
z: (String, String) = (x,y)

【2.访问元组】
使用_1、_2、_3....来访问元组中的元素,_1表示访问第一个元素,依次类推

// 1.可以直接使用括号来定义一个元组
scala> val a = (1, "张三", 20, "北京市")
a: (Int, String, Int, String) = (1,张三,20,北京市)
// 2.获取第一个元素
scala> a._1
res57: Int = 1
// 3.获取第二个元素
scala> a._2
res58: String = 张三
// 4.不能修改元组中的值
scala> a._1 = 2
<console>:13: error: reassignment to val
a._1 = 2
^

2.列表的使用详解

    List是scala中最重要的、也是最常用的数据结构。在scala中,也有两种列表,一种是不可变列表、另一种是可变列表。List具备以下性质:

  • 可以保存重复的值
  • 有先后顺序

2.1 不可变列表

不可变列表就是列表的元素、长度都是不可变的。
【1.语法格式】

  1. val/var 变量名 = List(元素1, 元素2, 元素3...)
  2. val/var 变量名 = Nil   //使用 Nil 创建一个不可变的空列表
  3. val/var 变量名 = 元素1 :: 元素2 :: Nil   //使用 :: 方法创建一个不可变列表
//方式1:使用 List(元素1, 元素2, 元素3, ...) 来创建一个不可变列表
scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1,2,3,4,5)

//方式2:使用Nil创建一个不可变的空列表
scala> val a = Nil
a: scala.collection.immutable.Nil.type = List()

//方式3:使用 :: 方法创建列表,包含-2、-1,3三个元素
scala> val a = -2 :: -1::3 :: Nil
a: List[Int] = List(-2, -1, 3)

2.2 可变列表

可变列表就是列表的元素、长度都是可变的。要使用可变列表。

要使用可变列表,先要导入 import scala.collection.mutable.ListBuffer
[尖叫提示]

  • 可变集合都在 mutable 包中
  • 不可变集合都在 immutable 包中(默认导入)

【1.语法格式】

  1. val/var 变量名 = ListBuffer[Int]()
  2. val/var 变量名 = ListBuffer(元素1,元素2,元素3...)
scala> val a = ListBuffer[Int]()
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
scala> val a = ListBuffer(1,2,3,4)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

【2.可变列表的操作】

  1. 获取元素(使用括号访问 (索引值) )
  2. 添加元素( += )
  3. 追加一个列表( ++= )
  4. 更改元素( 使用括号获取元素,然后进行赋值 )
  5. 删除元素( -= )
  6. 转换为List( toList )
  7. 转换为Array( toArray )
// 导入不可变列表
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
// 创建不可变列表
scala> val a = ListBuffer(1,2,3)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
// 获取第一个元素
scala> a(0)
res19: Int = 1
58
// 追加一个元素
scala> a += 4
res20: a.type = ListBuffer(1, 2, 3, 4)
// 追加一个列表
scala> a ++= List(5,6,7)
res21: a.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)
// 删除元素
scala> a -= 7
res22: a.type = ListBuffer(1, 2, 3, 4, 5, 6)
// 转换为不可变列表
scala> a.toList
res23: List[Int] = List(1, 2, 3, 4, 5, 6)
// 转换为数组
scala> a.toArray
res24: Array[Int] = Array(1, 2, 3, 4, 5, 6)

2.3 列表的常见操作(可变列表与不可变列表)

2.3.1 判断列表是否为空( isEmpty )

示例1:使用length方法来获取列表长度
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
60
scala> a.length
res0: Int = 4
scala> a.isEmpty
res16: Boolean = false
使用isEmpty代替 length == 0,效率更高

2.3.2拼接两个列表( ++ )

示例2:使用++方法来拼接连接列表来形成一个新的列表
scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)
scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)
scala> val c = a ++ b
c: List[Int] = List(1, 2, 3, 4, 5, 6)

2.3.3获取列表的首个元素( head )和剩余部分( tail )

示例3:获取列表的首个元素和剩余部分
1. 使用head方法,获取列表的首个元素
2. 使用tail方法,获取除第一个元素以外的元素,它也是一个列表
scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)
scala> a.head
res4: Int = 1
scala> a.tail
res5: List[Int] = List(2, 3)

2.3.1反转列表( reverse )

示例4:使用reverse方法将列表的元素反转
scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)
scala> a.reverse
res6: List[Int] = List(3, 2, 1)

2.3.1获取前缀( take )、获取后缀( drop )

示例5:获取列表的前缀、后缀以及使用take方法获取前n个元素
scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)
// 获取列表a的前3个元素
scala> a.take(3)
res10: List[Int] = List(1, 2, 3)
使用drop方法获取除了前3个元素以外的元素
scala> val a = List(1,2,3,4, 5)
a: List[Int] = List(1, 2, 3, 4, 5)
// 获取除了前3个元素以外的元素
scala> a.drop(3)
res11: List[Int] = List(4, 5)

2.3.1扁平化( flaten ),因为列表数组之类的都可以嵌套的。

示例6:扁平化操作,扁平化表示将列表中的列表中的所有元素放到一个列表中。使用flatten方法来进行扁平化
scala> val a = List(List(1,2), List(3), List(4,5))
a: List[List[Int]] = List(List(1, 2), List(3), List(4, 5))
62
scala> a.flatten
res15: List[Int] = List(1, 2, 3, 4, 5)

2.3.1拉链( zip )和拉开( unzip )

示例7:拉链与拉开
使用zip将两个列表,组合成一个元素为元组的列表
scala> val a = List("张三", "李四", "王五")
a: List[String] = List(张三, 李四, 王五)
scala> val b = List(19, 20, 21)
b: List[Int] = List(19, 20, 21)
scala> a.zip(b)
res16: List[(String, Int)] = List((张三,19), (李四,20), (王五,21))
使用unzip将一个包含元组的列表,解开成两个列表的元组
scala> res16.unzip
res17: (List[String], List[Int]) = (List(张三, 李四, 王五),List(19, 20, 21)
转换字符串

2.3.1转换字符串( toString )

示例8:toString返回列表的标准字符串表现形式
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
scala> println(a.toString)
List(1, 2, 3, 4)

2.3.1生成字符串( mkString )

示例9:mkString表示使用什么样的分隔符来展示列表
scala> a.mkString(",")
res20: String = 1,2,3,4
// 可以调用mkString的另一种重载方式,加上前缀和后缀
scala> a.mkString("[", ":", "]")
res22: String = [1:2:3:4]

2.3.1并集( union )

union表示对两个列表取并集,不去重
scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
// 并集操作
scala> a1.union(a2)
res17: List[Int] = List(1, 2, 3, 4, 3, 4, 5, 6)
// 可以调用distinct去重
scala> a1.union(a2).distinct
res18: List[Int] = List(1, 2, 3, 4, 5, 6)

2.3.1交集( intersect )

intersect表示对两个列表取交集,不去重
scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
scala> a1.intersect(a2)
res19: List[Int] = List(3, 4)

2.3.1差集( diff )

diff表示对两个列表取差集,例如: a1.diff(a2),表示将a1中不包含a2中的元素
scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)
scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)
scala> a1.diff(a2)
res24: List[Int] = List(1, 2)

3.Set的使用

Set(集)是代表没有重复元素的集合。在Scala中集set也分可变和不可变两种。Set具备以下性质:

  • 1. 元素不重复
  • 2. 不保证插入顺序

3.1 不可变集set

【1.语法格式】

  1. val/var 变量名 = Set[类型]()
  2. val/var 变量名 = Set[类型](元素1, 元素2, 元素3...)

【2.set的操作】

  1. 获取集的大小( size )
  2. 遍历集( 和遍历数组一致 )
  3. 添加一个元素,生成一个Set( + )
  4. 拼接两个集,生成一个Set( ++ )
  5. 拼接集和列表,生成一个Set( ++ )
// 创建集
scala> val a = Set(1,1,2,3,4,5)
a: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
// 获取集的大小
scala> a.size
res0: Int = 5
// 遍历集
scala> for(i <- a) println(i)
// 删除一个元素
scala> a - 1
res5: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4)
// 拼接两个集
scala> a ++ Set(6,7,8)
res2: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
// 拼接集和列表
scala> a ++ List(6,7,8,9)
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

3.2 可变集set

要使用可变集,必须要手动导入: import scala.collection.mutable.Set

scala> val a = Set(1,2,3,4)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)
// 添加元素
scala> a += 5
res25: a.type = Set(1, 5, 2, 3, 4)
// 删除元素
scala> a -= 1
res26: a.type = Set(5, 2, 3, 4)

4.Map映射的使用

Map可以称之为映射。它是由键值对组成的集合。在scala中,Map也分为不可变Map和可变Map。

4.1 不可变Map

【语法结构】

  1. val/var map = Map(键->值, 键->值, 键->值...) // 推荐,可读性更好
  2. val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)
scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40)
scala> val map = Map(("zhangsan", 30), ("lisi", 30))
map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 30)
// 根据key获取value
scala> map("zhangsan")
res10: Int = 30

4.2可变Map

可变Map需要手动导入 import scala.collection.mutable.Map 。定义语法与不可变Map一致

scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map
scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
// 修改value
scala> map("zhangsan") = 20

4.3 Map的操作(可变Map与不可变Map)

  1. Map基本操作
  2. 获取值( map(key) )
  3. 获取所有key( map.keys )
  4. 获取所有value( map.values )
  5. 遍历map集合
  6. getOrElse
  7. 增加key,value对
  8. 删除key
scala> val map = Map("zhangsan"->30, "lisi"->40)
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
// 获取zhagnsan的年龄
scala> map("zhangsan")
res10: Int = 30
// 获取所有的学生姓名
scala> map.keys
res13: Iterable[String] = Set(lisi, zhangsan)
// 获取所有的学生年龄
scala> map.values
res14: Iterable[Int] = HashMap(40, 30)
// 打印所有的学生姓名和年龄
scala> for((x,y) <- map) println(s"$x $y")
lisi 40
zhangsan 30
// 获取wangwu的年龄,如果wangwu不存在,则返回-1
scala> map.getOrElse("wangwu", -1)
res17: Int = -1
// 新增一个学生:wangwu, 35
scala> map + "wangwu"->35
res22: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30, wangw
u -> 35)
// 将lisi从可变映射中移除
scala> map - "lisi"
res23: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 30)

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页