Scala的数据结构

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

1.数组

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

数组的定义与使用

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

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

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

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

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

1.  
   import scala.collection.mutable.ArrayBuffer
2.  
   object ArrayDemo {
3.  
   def main(args: Array[String]): Unit = {
4.  
    
5.  
   //定义定长数组：定义长度为8的定长数组，数组中的每个元素都初始化为0
6.  
   val arr1 = new Array[Int](8)
7.  
    
8.  
   //打印数组，内容就是数组的hashcode值
9.  
   println(arr1)
10.  
     
11.  
    //定义变长数组（数组缓冲），需要导入包：import scala.collection.immutable.ArrayBuffer
12.  
    val ab = ArrayBuffer[Int]()
13.  
     
14.  
    //向变长数组中追加元素
15.  
    ab = 1
16.  
    //打印变长数组
17.  
    println(ab)
18.  
     
19.  
    //向变长数组追加多个元素
20.  
    ab = (2,3,4,5)
21.  
    println(ab)
22.  
     
23.  
    //追加一个定长数组
24.  
    ab = Array(6,7)
25.  
    println(ab)
26.  
     
27.  
    //追加一个变长数组(数组缓冲)
28.  
    ab =ArrayBuffer(8,9)
29.  
    println(ab)
30.  
     
31.  
    //在变长数组中的某个位置插入元素
32.  
    ab.insert(0,-1,0) //insert()中有两个参数 第一个参数为插入的位置 第二个参数为插入的元素
33.  
    println(ab)
34.  
     
35.  
    //删除数组的某个元素
36.  
    ab.remove(0) //remove() 参数为删除元素的位置 即下标
37.  
    println(ab)
38.  
    }
39.  
    }

 1.2数组遍历

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

1.  
   object ArrayTraversal {
2.  
   def main(args: Array[String]): Unit = {
3.  
   //定义定长数组
4.  
   // val ints = new Array[Int](8) 方式一
5.  
   val arr = Array(1, 2, 3, 4, 5) //方式二
6.  
    
7.  
   //打印输出数组中的所有元素
8.  
   for(x<-arr){
9.  
   print(x " ")
10.  
    }
11.  
     
12.  
    //计算数组中所有元素的和
13.  
    var total=0
14.  
    for(i<-arr){
15.  
    total =i
16.  
    }
17.  
    println(total)
18.  
     
19.  
    //查找元素中最大的数
20.  
    var max =0
21.  
    for(i<-0 to arr.length-1){
22.  
    if(arr(i)>max){
23.  
    max=arr(i)
24.  
    }
25.  
    }
26.  
    print(max)
27.  
    }
28.  
    }

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列表。例如，定义一个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集合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集合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)
  }
}

这篇好文章是转载于：学新通技术网