Scala的数据结构

在编写程序代码时，经常需要用到各种数据结构，选择合适的数据结构可以带来更高的运行或者存储效率，Scala提供了许多数据结构，例如常见的数组、元组和集合等。

1. 数组

数组是重要的数据结构之一，主要用来存储数据类型相同的元素。

1.1 数组的定义与使用

Scala中的数组分为 定长数组 和 变长数组；定义方式如下：

new Aarray[T](数组长度)       //定义定长数组
ArrayBuffer[T]()             //定义变长数组

上述语法格式中，定义定长数组，需要使用new关键字，而定义变长数组时，则需要导入包：import scala.collection.mutable.ArrrayBuffer ；[ T ]表示的是数组元素类型，T为泛型即参数化类型；

当定义好数组后，可以对数组进行追加、插入以及删除等操作。针对不同数组的操作，Array提供了不同的API。

通过一个简单的栗子演示Scala数组的简单使用：

import scala.collection.mutable.ArrayBuffer
object ArrayDemo{
  def main(args:Array[String]){
    //初始化一个长度为8的定长数组，其他元素均为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的hashcode值
    println(arr1)
    //变长数组(数组缓冲)
    //如果使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer
    val ab = ArrayBuffer[Int]()
    //向数组缓冲尾部追加一个元素
    // += 表示尾部追加元素
    ab += 1
    println(ab)
    // 追加多个元素
    ab += (2,3,4,5)
    println(ab)
    // 追加一个数组 ++=
    ab ++= Array(6,7)
    println(ab)
    // 追加一个数组缓冲
    ab ++= ArrayBuffer(8,9)
    println(ab)
    // 在数组某个位置插入元素用insert，从某下标插入
    ab.insert(0,0)
    println(ab)
    // 删除数组某个位置的元素用remove按照下标删除
    ab.remove(0)
    println(ab)
  }
}

上述代码中，第5-7行代码定义了一个定长数组arr1；第10-30行代码定义了一个变长数组ab并对数组对象进行了追加、插入和删除等操作。

Scala数组定义与使用输出的结果：

1.2 数组遍历

数组遍历有3种方式，分别是for循环遍历、while循环遍历以及do…while循环遍历；

栗子：for循环对数组进行遍历操作

object test_for {
  def main(args: Array[String]): Unit = {
    var myArr = Array(1.2,2.4,3.6,4.8)
    // 打印输出所有的数组元素
    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 (myArr(i) > max) max = myArr(i)
    }
    println("最大值为："+max)
  }
}

for循环对数组进行遍历操作输出结果：

1.3 数组转换

数组转换是通过yield关键字将原始的数组进行转换，会产生一个新的数组，然而原始的数组保存不变。

栗子：定义一个数组，实现将偶数取出乘以5后生成一个新的数组

object test_yield {
  def main(args: Array[String]): Unit = {
    // 定义一个数组
    val arr = Array(1,2,3,4,5,6,7,8,9)
    // 将偶数取出乘以5后生成一个新的数组
    val newArr = for(e<- arr if e%2==0) yield e*5
    println(newArr.toBuffer)
  }
}

输出结果：

2 元组

Scala元组是对多个不同类型对象的一种简答封装，它将不同的值用小括号括起来,并用逗号分隔。

2.1 创建元组

创建元组的语法格式：valtuple = (元素，元素......)
元组内可以包含不同的数据类型
栗子：创建一个包含String类型、Double类型、Int类型的元组：

2.2 获取元组中的值

获取元组的值：通过添加下划线和脚标来获取(tuple._1),元组中的元素脚标从1开始。
栗子：分别获取元组中第一个、第二个和第三个元素的值

2.3 拉链操作

Scala的元组中可以使用zip命令将多个值绑定在一起。(类似压缩)
栗子：两个元素个数相同的元组进行拉链操作后生成的数组

若两个数组的元素个数不一致，则拉链操作后生成的数组的长度为较小的数组元素个数；

栗子：两个元素个数不同的元组进行拉链操作后生成的数组

3 集合

集合有三大类：List、Set、Map
Scala集合分为可变的(mutable)和不可变(immutable)的集合:

• 可变集合：可对集合元素进行修改、添加、删除
• 不可变集合：初始化后永远不会改变，可通过模拟来添加、移除或更新元素，但这些操作都返回一个新集合，同时保持原集合不变，类似浅拷贝。

3.1 List

列表的所有元素都具有相同的类型，列表与数组不同的是，列表是不可变的(既列表的元素不能通过赋值来更改)

列表也分为List和ListBuffer，List的内容长度不可变，而ListBuffer的内容长度是可变的，前提需要先导入包：
import scala.collection.mutale.ListBuffer

栗子：定义不同类型列表List

object test_list {
  def main(args: Array[String]): Unit = {
    //字符串
    val food = List("egg","milk","bread")
    //整形
    val num = List(1.5,4,6)
    //空
    val empty = List()
    //二维列表
    val dim =
      List(
        List(1,0,1,0),
        List(0,1,0,1),
        List(1,0,1,0)
      )
    println(food)
    println(num)
    println(empty)
    println(dim)
  }
}

输出结果：

在Scala中，还可以使用 Nil 和 :: 操作符来定义列表。其中Nil表示空列表，:: 表示向列表的头部追加数据，创造新数据。

栗子：使用Nil和 :: 操作符定义列表

object list {
  def main(args: Array[String]): Unit = {
      // 字符串
      val food = "egg"::("milk"::("bread"::Nil))
      // 整形
      val nums = 1.5::(4::(6::Nil))
      // 空列表
      val empty = Nil
      // 二维列表
      val dim = (1::(0::(0::Nil))) ::
        (0::(1::(0::Nil))) ::
        (0::(0::(1::Nil))) :: Nil
  }
}

列表List作为Scala中的数据结构之一，Scala也提供了很多操作List的方法。

栗子：实践操作List列表的常见方法

object operate_list {
  def main(args: Array[String]): Unit = {
    val food = "egg"::("milk"::("bread"::Nil))
    val num = Nil
    println("head of food:"+food.head)
    println("tail of food:"+food.tail)
    println("check if food is empty:"+food.isEmpty)
    println("check if num is empty:"+num.isEmpty)
    println("take of food:"+food.take(2))
    println("contains of food:"+food.contains("milk"))
  }
}

输出结果：

3.2 Set

在scala中，Set是没有重复对象的集合，所有元素都是唯一的。
默认情况下，Scala使用不可变Set集合，若想使用可变的Set集合，则需要导入包：import scala.collection.mutable.Set

定义Set集合的语法格式如下：

val set : Set[ Int ] = Set(元素1，元素2，元素3，......)

操作Set集合也有很多常见的方法，跟List常见方法相同

栗子：定义一个Set集合site，使用常见的方法对集合site进行相关操作

object set {
  def main(args: Array[String]): Unit = {
    val site = Set("Sougou","Google","Baidu")
    val num:Set[Int] = Set()
    println("第一个网站："+site.head)
    println("其余网站："+site.tail)
    println("查看site集合是否为空："+site.isEmpty)
    println("查看num集合是否为空："+num.isEmpty)
    println("查看site的前2个网站："+site.take(2))
    println("查看集合是否包含网站Sougou："+site.contains("Sougou"))
  }
}

输出结果：

3.3 Map

在scala中，Map是一种可迭代的键值对(key/value)结构，并且键是唯一的，值不一定是唯一的，所有的值都是通过键来获取的。
Map中所有元素的键与值都存在一种对应关系，这种关系既映射。
Map有2种类型，可变与不可变，区别在于可变对象可修改，而不可变对象不可修改。
在scala中，默认使用不可变Map，若需要使用可变Map集合，则需要引入类：import scala.collection.mutable.Map

定义Map集合的语法格式：

var A:Map[ Char , Int ] = Map(键->值，键->值...)   //Char为键，Int为值

Scala也提供了很多操作Map集合的方法：
栗子：定义Map集合colors，使用Map常见的方法集合colors进行相关操作

object test_map {
    def main(args: Array[String]): Unit = {
      val colors = Map("red"->"1","azure"->"2","peru"->"3")
      val perucolors = if(colors.contains("peru"))colors("peru") else 0
      val azurecolors = colors.getOrElse("azure",0)
      println("获取colors中键为read的值："+colors("red"))
      println("获取colors中所有的键："+colors.keys)
      println("获取colors中所有的值："+colors.values)
      println("获取colors中是否为空："+colors.isEmpty)
      println("获取colors中是否包含键peru，包含则返回对应值，否则返回0："+perucolors)
      println("获取colors中是否包含键azure，包含则返回对应值，否则返回0："+azurecolors)
    }
}

输出结果：

本博客到此就结束嘞，有帮助或学到东西的话，给个点赞支持一下吧，制作不易，我是不吃泡面，不只会写BUG，关注我，持续更新Scala语言基础的内容，有什么问题欢迎评论区留言指正噢，我们下期再见。