Scala的数据结构

Scala提供了许多数据结构，例如常见的数组、元组、和集合等。

1.数组

数组（Array）主要用来存储数据类型相同的元素

数组的定义与使用

Scala中的数组分为定长数组和变长数组，这两种数组的定义方式如下：

1   new Array[T]（数组长度）                                   //定义定长数组

2   ArrayBuffer[T]（）                                               //定义变长数组

注意：定义变长数组时，需要导入包import scala.collection.mutable.ArrayBuffer

下面，我们通过一个例子来演示Scala数组简单使用

import scala.collection.mutable.ArrayBuffer
object ArrayDemo {
  def main(args: Array[String]): Unit = {

    //定义定长数组：定义长度为8的定长数组，数组中的每个元素都初始化为0
    val arr1 = new Array[Int](8)

    //打印数组，内容就是数组的hashcode值
    println(arr1)

    //定义变长数组（数组缓冲），需要导入包：import scala.collection.immutable.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)

    //在变长数组中的某个位置插入元素
    ab.insert(0,-1,0)     //insert()中有两个参数 第一个参数为插入的位置 第二个参数为插入的元素
    println(ab)

    //删除数组的某个元素
    ab.remove(0)         //remove() 参数为删除元素的位置 即下标
    println(ab)
  }
}

 1.2数组遍历

Scala中，如果想要获取数组中的每一个元素，则需要将数组进行遍历操作

object ArrayTraversal {
  def main(args: Array[String]): Unit = {
    //定义定长数组
    // val ints = new Array[Int](8) 方式一
    val arr = Array(1, 2, 3, 4, 5) //方式二

    //打印输出数组中的所有元素
    for(x<-arr){
      print(x+" ")
    }

    //计算数组中所有元素的和
    var total=0
    for(i<-arr){
      total+=i
    }
    println(total)

    //查找元素中最大的数
    var max =0
    for(i<-0 to arr.length-1){
      if(arr(i)>max){
        max=arr(i)
      }
    }
    print(max)
  }
}

1.3数组转换

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

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

object ArrayYieldTest{

            def  main(args:Array[String]){

                          //先定义一个数组

                    val arr = Array(1,2,3,4,5,6,7,8,9)

                    val newarr = for(e<-arr if e%2==0)yield e*10

                    printf(newarr.toBuffer)

             }

}

---

2.元组

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

2.1创建元组

创建元组的语法格式如下

1  val tuple=(元素,元素....)

下面通过简单的例子创建元组。例如，创建一个包含String类型，Double类型以及int类型的元组，具体代码如下：

scala> val tuple= ("itcast",3.1415,6335) 

tuple:(String,Double,Int)=(itcast,3.1415,6335)

2.2获取元组中的值 

在Scala中，获取元组中的值是通过下划线加脚标来获取的，元组中的元素脚标是从1开始的，它与数组下标从0开始不同。

1   scala> tuple._1                     //获取第一个值

2   res2: String = itcast

3

4   scala>tuple._2                      //获取第二个值

5   res3:Double = 3.1415  

2.3拉链操作 

在Scala的元组中，可以通过使用zip命令将多个值绑定在一起。例如，定义两个数组，分别是scores和names，并将这两个数组捆绑在一起

1   scala> val scores = Array（90,85,80） 

2   scores:Array[Int]=Array（90,85,80）

3

4   scala> val names = Array（"zhang","li","wang"）

5   names:Array[String]=Array（zhang，li，wang）

6

7   scala>names.zip（scores）

8   res5：Array[（String，Int）] = Array（（zhang，90），（li，85），（wang，80））

3.集合 

Scala中，集合分为三大类：List，Set以及Map

Scala集合分为可变的（mutable）和不可变（immutable）的集合。

---

3.1List

 在Scala中，List列表和数组类似，列表的所有元素都具有相同类型。这里的List默认是不可变列表，如果要定义可变列表，需要导入“import scala.collection.mutable.ListBuffer”包

定义不同类型列表List，具体代码如下

1                              //字符串

2   val fruit ：List[String]=List（"apple","pear","orange"）

3

4            //整型

5   val num：List[Int]=List（1,2,3,4）

5

6      //空

7   val empty：List[Nothing]=List（）

8

9   //二维列表

10  val dim：List[List[Int]]=List（List（0,0,1），List（0,1,0），List（1,0,0））

在Scala中，可以使用"“Nil”和"::"操作符来定义列表 。双冒号可以理解为一个方法

1            //字符串

2            val fruit = “apple”::("orange"::("pear"::Nil))

3  

4           //整型

5           val num =1::(2::(3::(4::Nil)))

6

7           //空列表

8           val empty =Nil

9

10         //二维列表

11         val dim = (1::(2::(3::Nil)))   ::

                            (1::(2::(3::Nil)))   ::

                            (1::(2::(3::Nil)))   ::Nil 

 Scala也提供了很多操作List的方法

List方法

方法名称	相关说明
head	获取列表的第一个元素
tail	返回除第一个之外的所有元素组成的列表
isEmpty	若列表为空，则返回true，否则返回false
take	获取列表前n个元素
contains	判断是否包含指定元素

通过简单例子演示操作List列表。例如，定义一个fruit列表，使用常见的方法对列表fruit进行相关操作。

1      object ListTest{

2            def main（args：Array[String]）{

                    val fruit  =“apple” ::(orange::(pear::Nil))           

                    val num = Nil       

                    println("Head of fruit : "+fruit.head)

                    println("Tail of fruit : "+fruit.tail) 

                    println("Check if fruit is empty: "+fruit.isEmpty)

                    println("Check if fruit is empty : "+num.isEmpty) 

                    println("Take of fruit : "+fruit.take(2))

                    println("Contains of fruit : "+fruit.contains("apple"))

                                        }

}

3.2 Set

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

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

1     val set ：Set[Int] = Set（1,2,3,4,5）

Scala提供了很多操作Set集合的方法，以下列举一些操作Set集合的常见方法

Set方法

方法名称	相关说明
head	获取Set集合的第一个元素
tail	返回除第一个之外的所有元素组成的Set集合
isEmpty	若Set集合为空，则返回true，否则返回false
take	获取Set集合前n个元素
contains	判断Set集合是否包含指定元素

定义一个Set集合site，使用常见方法对Set集合进行操作

object SetTest {
  def main(args: Array[String]): Unit = {
    //定义Set集合
    val site=Set("Itcast","Goole","Baidu")
    val num:Set[Int]=Set()

    println("第一个网站是:"+site.head)
    println("除了第一个网站其他为:"+site.tail)
    println("查看集合site是否为空:"+site.isEmpty)
    println("查看集合num是否为空:"+num.isEmpty)
    println("查看site的前两个元素:"+site.take(2))
    println("查看site中是否包含Baidu:"+site.contains("Baidu"))
  }
}

 

3.Map 

在Scala中，Map是一种可迭代的键值对（key/value）结构，并且键是唯一的。若需要使用可变的Map集合，需要引入import scala.collection.mutable.Map 类

定义Map集合的语法结构如下：

1    val A：Map[Char,Int] = Map(键 -> 值,键 -> 值...)  //Map键值对，键为Char，值为Int

 Scala也提供了很多操作Map集合的方法，以下列举一些操作Map集合的常见方法

Map方法

方法名称	相关说明
（）	根据某个键查找对应的值，类似于java中的get（）
contains（）	检查Map中是否包含某个特定的键
getOrElse（）	判断是否包含键，若包含返回对应的值，否则返回其他的
keys	返回Map所有的键（key）
values	返回Map所有的值（value）
isEmpty	若Map为空时，返回true

接下来，定义一个Map集合colors，以下使用Map常用的方法对集合colors进行相关的操作

object MapTest {
  def main(args: Array[String]): Unit = {
    //定义Map集合
    val colors:Map[String,String]=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中是否包含键peru，包含则返回对应的值，否则返回0:"+azureColor)
  }
}