Scala数据结构

1.数组：

1.1定长数组：

1.1.1 特点：

• 数组的长度不可变
• 数组的内容可变

1.1.2 语法：

• 通过制定长度定义数组

val/var 变量名 = new Array[元素类型](数组长度)

• 通过指定元素定义数组

val/var 变量名 = Array(元素1,元素2...)

注意：

• 在Scala中，数组的泛型使用[]来指定
• 使用数组名(索引)来获取数组中的元素
• 数组元素是有默认值的，Int:0,Double:0.0,String:null
• 通过数组名.length 或数组名.size来获取数组的长度

1.1.3 实例：

• 定义一个长度为10的整数数组，设置第一个元素为11，并打印第一个元素。

val sz = new Array[Int](10)
sz(0) = 11
println(sz(0))

• 定义一个包含"java",“python”,"scala"这三个元素的数组，并打印数组的长度。

val sz_f = Array("java","python","scala")
println(sz_f.length) // 数组长度
println(sz_f.size)// 数组长度

1.2变长数组：

1.2.1 特点：

数组的长度和内容都是可变的，可以往数组中添加，删除元素。

1.2.2 语法：

创建变长数组，需要到如ArrayBufer类：

import scala.collection.mutable.ArrayBuffer

定义格式一：创建空的ArrayBuffer变长数组

val/var 变量名 =  ArrayBuffer[元素类型]()

定义格式二：创建带有初始元素的ArrayBuffer数组。

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

1.2.3实例：

• 定义一个长度为0的整型变长数组
• 定义一个包含"hadoop",“strom”,"spark"这三个元素的变长数组
• 打印结果

import scala.collection.mutable.ArrayBuffer

val n1 = ArrayBuffer[Int]()  // 定义一个长度为0的整型变长数组

val n2 = ArrayBuffer("hadoop", "strom", "spark") //定义一个包含"hadoop","strom","spark"这三个元素的变长数组

println(n2)
// ArrayBuffer(hadoop, strom, spark)

1.2.4增删改元素：

格式：

• 使用 += 添加单个元素
• 使用 -= 删除单个元素
• 使用 ++= 追加一个数组到变长数组中
• 使用 --= 移除变长数组中的指定多个元素

import scala.collection.mutable.ArrayBuffer

val n1 = ArrayBuffer[String]() // 定义空变长数组

n1 += "hadoop"
n1 -= "hadoop"

n1 ++= Array("spark", "scala")
n1 --= Array("spark", "scala")
println(n1)

1.3遍历数组：

遍历数组的两种形式：

• 使用索引遍历数组元素
• 使用for表达式直接遍历数组中的元素

实例：

• 定义一个数组，包含以下元素:1,2,3,4,5
• 通过两种遍历方式遍历数组

import scala.collection.mutable.ArrayBuffer

val n1 = ArrayBuffer(1, 2, 3, 4, 5)
println("*"*15)
for (i <- 0 to n1.size - 1) println(n1(i)) //使用索引遍历数组元素
for (i <- 0 until n1.size) println(n1(i))  // until 遍历
println("*"*15)
for (i <- n1) println(i)  //使用for表达式直接遍历数组中的元素，开发中比较推荐这种方式来实现

1.4 数组的常用算法

常用算法：

• sum()方法：求和
• max()方法：最大值
• min()方法：最小值
• sorted()方法:排序，返回一个新的数组
• reverse() 方法：翻转，返回一个新的数组

2.元祖

元组一般用来存多个不同类型的值。元祖的长度和元素都是不可变的。

2.1格式：

val/var 元祖 = (元素1, 元素2)

val/var 元祖 = 元素1-> 元素2  // 只适用于只有两个元素的情况

2.2访问元祖中的元素：

格式：

• 访问单个元素：

元组名._1   // 访问第一个元素
元组名._2  // 访问第二个元素

• 遍历元祖：

val tp = ...

val it = tp.productIterator

for(i <- it) println(i)

3.列表

特点：有序，可重复。

3.1不可变列表

指列表的长度、元素都不可变。

语法：

val/var 变量名 = List(元素1,元素2,元素3...)

val/var 变量名 = Nil //空列表

val/var 变量名 = 元素1::元素2::Nil // 这种形式必须在最后添加Nil

3.2可变列表

特点：列表的长度、元素都是可变的

语法：

import scala.collection.mutable.ListBuffer

val/var 变量名 = ListBuffer[数据类型]() //空可变列表

val/var 变量名 = ListBuffer(元素1,元素2,元素3...)

3.3可变列表的操作常用操作

格式	功能
列表名(索引)	根据索引（从0开始），获取列表中的指定位置的元素
列表名(索引) = 值	修改元素的值
+=	往列表中添加单个元素
++=	往列表中追加一个列表
-=	删除列表中的某个特定元素
–=	列表的形式，删除列表中的多个元素
toList	将可变列表转换为不可变列表
toArray	可变列表转换为数组

3.4列表的常用操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a4A4OR4E-1615037443915)(C:\Users\Renwl\AppData\Roaming\Typora\typora-user-images\image-20201209220845384.png)]

3.5扁平化处理

val ls = List("acd", 1, true)
val ls2 = List(3, 1, 5, 6)
val ls3 = List(ls, ls2)
println(ls3)  // List(List(acd, 1, true), List(3, 1, 5, 6))
println(ls3.flatten) //List(acd, 1, true, 3, 1, 5, 6)

3.6拉链和拉开处理

val l1 = List("张三", "李四", "王五")
val l2 = List(22, 23, 24)

val ls3 = l1.zip(l2)
val tp1 = ls3.unzip

println(s"拉链：${ls3}") //拉链：List((张三,22), (李四,23), (王五,24))
println(s"拉开：${tp1}") //拉开：(List(张三, 李四, 王五),List(22, 23, 24))

3.7转换字符串

toString

mkString : 可以指定分割符分割

val l2 = List(22, 23, 24)

println(l2.toString) //List(22, 23, 24)
println(l2) // 跟toString一致是因为调用对象，则默认调用对象toString方法，  List(22, 23, 24)
println(l2.mkString("--"))    // 22--23--24

3.8并集、交集、差集

union：对两个列表取并集，且不去重

intersect: 两个列表取交集

diff: 两个列表取差集

4.集

4.1 概述：

Set，代表没有重复的元素，特点：唯一，无序

可变集与不可变集

4.2不可变集：

不可变集元素和长度都不可变

4.2.1语法：

• 格式一：创建一个空的不可变集

  val/var 变量名 = Set[数据类型]()
  

• 格式二：给定元素来创建一个不可变集

  val/var 变量名 = Set(元素1, 元素2...)
  

4.3可变集

指元素，集的长度都可变，它的常见方式和不可变集方式一样，需要导入可变集类。

import scala.collection.mutable.Set

val set1 = Set(1,2,3,4)
set1 += 5 //添加元素
set1 ++= List(6,7,8)
set1 -= 1 // 剔除元素 1 
set1 --= List(3,5,7) // 删除元素