Spark大数据分析与实战笔记（第一章 Scala语言基础-3）

1.3 Scala的数据结构

对于每一门编程语言来说，数组（Array）都是重要的数据结构之一，主要用来存储数据类型相同的元素。Scala中的数组分为定长数组和变长数组，定义定长数组，需要使用new关键字，而定义变长数组时，则需要导包import scala.collection.mutable.ArrayBuffer。

1.3.1 数组

数组（Array）主要用来存储数据类型是每个人元素。

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

• 定义定长数组
  New Array[T] (数组长度) //定义定长数组

• 定义变长数组
  ArrayBufferT //定义变长数组

注：定义定长数组，需要使用new关键字，而定义变长数组时，则需要导包import scala.collection.mutable.ArrayBuffer。

下面，通过一个例子来演示Scala数组简单使用，具体代码如下所示。

package cn.itcast.scala

import scala.collection.mutable.ArrayBuffer

object Ch01_ArrayDemo {

  def main(args: Array[String]): Unit = {

    //定义定长数组：定义长度为8的定长数组，数组中的每个元素初始化为0

    val arr1 = new Array[Int](8)

    //打印数组,内容是数组的hashcode值

    println(arr1)

//定义变长数组（数组缓冲），需要导入包：import scala.collection.mutable.ArrayBuffer

    val arr2 = ArrayBuffer[Int]()

    //向变长数组中追加元素

    arr2 += 1

    //打印变长数组

    println(arr2)

    //向变长数组中追加多个元素

    arr2 += (2,3,4,5)

    println(arr2)

    //追加一个定长数组

    arr2 ++= Array(6,7)

    println(arr2)

    //追加一个变长数组(数组缓冲)

    arr2 ++= ArrayBuffer(8,9)

    println(arr2)

    //在变长数组的某个位置插入元素

    arr2.insert(0,-1,0)

    println(arr2)

    //删除数组的某个元素

    arr2.remove(0)

    println(arr2)

  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

数组的遍历

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

package cn.itcast.scala

object Ch02_ArrayTraversal {

  def main(args: Array[String]): Unit = {

    //定义定长数组

    //val array = new Array[Int](8) //方式1

    val myArr = Array(1.9, 2.9, 3.4, 3.5) //方式2

    //打印输出数组中的所有元素

    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(max < myArr(i)){

        max = myArr(i)

      }

    }

    println("最大值为："+max)

  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

数组转换

数组转换就是通过yield关键字将原始的数组进行转换，会产生一个新的数组，然而原始的数组保持不变。定义一个数组，实现将偶数取出乘以10后生成一个新的数组，具体代码如下所示：

package cn.itcast.scala

object Ch03_ArrayYieldTest {

  def main(args: Array[String]): Unit = {

    //定义一个数组

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

    //将偶数取出乘以10后再生成一个新的数组

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

    println(newArr.toBuffer) //将定长数组转为变长数组

  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.3.2 元组

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

创建元组

创建元组的语法格式如下：

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

下面，通过简单的例子进行演示创建元组，例如：创建一个包含String类型、Double类型以及Int类型的元组，具体代码如下：

scala> val tuple = ("itcast",3.14,65535)

tuple: (String, Double, Int) = (itcast,3.14,65535)
1
2
3

获取元组中的值

在Scala中，获取元组中的值是通过下划线加脚标（例如：tuple._1，tuple._2）来获取的，元组中的元素脚标是从1开始的。代码如下：

scala> tuple._1                         # 获取第一个值

res0: String = itcast

scala> tuple._2                         # 获取第一个值

res1: Double = 3.14
1
2
3
4
5
6
7

拉链操作

在Scala的元组中，可以通过使用“zip”命令将多个值绑定在一起。例如，定义两个数组，分别是score和names，将这两个数组捆绑在一起，具体代码如下：

scala> val scores = Array(88,95,80)

scores: Array[Int] = Array(88, 95, 80)

scala> val names =Array("zhangsan","lisi","wangwu")

names: Array[String] = Array(zhangsan, lisi, wangwu)

scala> names.zip(scores)

res2: Array[(String, Int)] = Array((zhangsan,88), (lisi,95), (wangwu,80))
1
2
3
4
5
6
7
8
9
10
11

注：当两个数组个数不等时，会自动适配较短长度，多余元素无相应匹配元素会被自动抛弃。

1.3.3 集合

在Scala中，集合有三大类： List、Set以及Map，所有的集合都扩展自Iterable特质。

Scala 集合分为可变的（mutable）和不可变（immutable）的集合。其中，可变集合可以在适当的地方被更新或扩展，意味着可以对集合进行修改、添加、移除元素；不可变集合类，相比之下，初始化后就永远不会改变。

List

在Scala中，List列表和数组类似，列表的所有元素都具有相同类型。然而，列表与数组不同的是，列表是不可变的。

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

// 字符串

val fruit: List[String] =List("apples","oranges","pears")

// 整型

val nums: List[Int] = List(1, 2, 3, 4)

// 空

val empty: List[Nothing] = List()

// 二维列表

val dim: List[List[Int]] =

            List(

            List(1, 0, 0),

            List(0, 1, 0),

            List(0, 0, 1)

 )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在Scala中，可以使用“Nil”和“：：”操作符来定义列表。代码如下：

// 字符串

val fruit = "apples":: ("oranges":: ("pears" :: Nil))

// 整型

val nums = 1 :: (2 :: (3 :: ( 4 :: Nil)))

// 空列表

val empty = Nil

// 二维列表

val dim = (1 :: (0 :: (0 :: Nil))) ::

                (0 :: (1 :: (0 :: Nil))) ::

                (0 :: (0 :: (1 :: Nil))) :: Nil
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Scala也提供了很多操作List的方法，如下表所示。

示例代码如下：

package cn.itcast.scala

object Ch04_ListTest {

  def main(args: Array[String]): Unit = {

    //定义List集合

    //val fruit:List[String] = List("apples","oranges","pears")

    val fruit = "apples"::("oranges"::("pears"::Nil))

    val nums = Nil

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

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

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

    println("check if nums is empty:"+nums.isEmpty)

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

    println("contains of fruit oranages:"+fruit.contains("oranges"))

  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

Set

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

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

val set: Set[Int] = Set(1,2,3,4,5)
1

Scala提供了很多操作Set集合的方法。接下来，我们列举一些操作Set集合的常见方法，具体如下表所示。

具体代码如下所示：

package cn.itcast.scala

object Ch05_SetTest {

  def main(args: Array[String]): Unit = {

    //定义Set集合

    val site = Set("Itcast","Google","Baidu")

    val nums:Set[Int] = Set()

    println("第一个网站是："+site.head)

    println("最后一个网站是："+site.tail)

    println("site集合是否为空："+site.isEmpty)

    println("nums集合是否为空："+nums.isEmpty)

    println("查看site集合的前两个网站："+nums.take(2))

    println("site集合中是不包含网站Google："+site.contains("Google"))

  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Map

在Scala中，Map是一种可迭代的键值对（key/value）结构，并且键是唯一的，值不一定是唯一的，所有的值都是通过键来获取的。Map中所有元素的键与值都存在一种对应关系，这种关系即为映射。Map有两种类型，可变集合与不可变集合，默认是不可变Map。若需要使用可变的Map集合，则需要引入 import scala.collection.mutable.Map 类。

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

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

Scala也提供了很多操作Map集合的方法。接下来，我们列举一些操作Map集合的常见方法，具体如下表所示：

示例代码如下所示：

package cn.itcast.scala

object Ch06_MapTest {

  def main(args: Array[String]): Unit = {

    //定义Map集合

    val colors = 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中是否包含键azure，包含则返回对应的值，否则返回0："+azureColor)

  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

转载自:https://blog.csdn.net/u014727709/article/details/131679759

欢迎start，欢迎评论，欢迎指正