Spark大数据分析实战最新章节_张伟洋著

1.4 集合

Scala集合分为可变集合和不可变集合。可变集合可以对其中的元素进行修改、添加、移除；而不可变集合永远不会改变，但是仍然可以模拟添加、移除或更新操作。这些操作都会返回一个新的集合，原集合的内容不发生改变。

1.4.1 数组

Scala中的数组分为定长数组和变长数组，定长数组初始化后不可对数组长度进行修改，而变长数组则可以修改。

1．定长数组

（1）数组定义

定义数组的同时可以初始化数据，代码如下：

val arr=Array(1,2,3)       //自动推断数组类型
或者
val arr=Array[Int](1,2,3)  //手动指定数据类型

也可以在定义时指定数组长度，稍后对其添加数据，代码如下：

val arr=new Array[Int](3)
arr(0)=1
arr(1)=2
arr(2)=3

（2）数组遍历

可以使用for循环对数组进行遍历，输出数组所有的元素，代码如下：

val arr=Array(1,2,3)
for(i<-arr){
  println(i)
}

（3）常用方法

Scala对数组提供了很多常用的方法，使用起来非常方便，代码如下：

val arr=Array(1,2,3)
//求数组中所有数值的和
val arrSum=arr.sum
//求数组中的最大值
val arrmAx=arr.max
//求数组中的最小值
val arrMin=arr.min
//对数组进行升序排序
val arrSorted=arr.sorted
//对数组进行降序排序
val arrReverse=arr.sorted.reverse

2．变长数组

（1）数组定义

变长数组使用类scala.collection.mutable.ArrayBuffer进行定义，例如以下代码：

//定义一个变长Int类型数组
val arr=new ArrayBuffer[Int]()
//向其中添加3个元素
arr+=1
arr+=2
arr+=3
println(arr)

上述代码输出结果为：

ArrayBuffer(1, 2, 3)

也可以使用-=符号对变长数组中的元素进行删减，例如，去掉数组arr中值为3的元素：

arr-=3

若数组中有多个值为3的元素，则从前向后删除第一个匹配的值。

（2）数组合并

Scala支持使用++=符号将两个变长数组进行合并，例如，将数组a2的所有元素追加到数组a1中，代码如下：

val a1=ArrayBuffer(1,2,3,4,5)
val a2=ArrayBuffer(6,7)
println(a1++=a2)

输出结果如下：

ArrayBuffer(1, 2, 3, 4, 5, 6, 7)

（3）在固定位置插入元素

使用insert()方法可以在数组指定的位置插入任意多个元素，例如，在数组arr的下标为0的位置插入两个元素1和2，代码如下：

arr.insert(0,1,2)

（4）在固定位置移除元素

使用remove()方法可以在数组的固定位置移除指定数量的元素，例如，从数组arr的下标为1的位置开始移除两个元素，代码如下：

val arr=ArrayBuffer[Int](1,2,3,4,5)
arr.remove(1, 2)
println(arr)

输出结果如下：

ArrayBuffer(1, 4, 5)

1.4.2 List

Scala中的List分为可变List和不可变List，默认使用的List为不可变List。不可变List也可以增加元素，但实际上生成了一个新的List，原List不变。

1．不可变List

例如，创建一个Int类型的List，名为nums，代码如下：

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

在该List的头部追加一个元素1，生成一个新的List：

val nums2=nums.+:(1)

在该List的尾部追加一个元素5，生成一个新的List：

val nums3=nums:+5

List也支持合并操作，例如，将两个List合并为一个新的List，代码如下：

val nums1: List[Int] = List(1, 2, 3)
val nums2: List[Int] = List(4, 5, 6)
val nums3=nums1++:nums2
println(nums3)

输出结果如下：

List(1, 2, 3, 4, 5, 6)

此外，常用的还有二维List：

2．可变List

可变List需要使用scala.collection.mutable.ListBuffer类。

例如，创建一个可变List并初始化数据：

val listBuffer= ListBuffer(1, 2, 3)

或者创建时不初始化数据，而是通过后面添加元素：

val listBuffer= new ListBuffer[Int]()
listBuffer+=1
listBuffer+=2
listBuffer+=3

也可以将两个List进行合并：

val listBuffer= ListBuffer(1, 2, 3)
val listBuffer3= ListBuffer(4, 5, 6)
println(listBuffer++listBuffer3)

输出结果为：

ListBuffer(1, 2, 3, 4, 5, 6)

1.4.3 Map映射

Scala中的Map也分可变Map和不可变Map，默认为不可变Map。

1．不可变Map

创建一个不可变Map的代码如下：

val mp = Map(
   "key1" -> "value1",
   "key2" -> "value2",
   "key3" -> "value3"
)

也可以使用以下写法：

val mp = Map(
   ("key1" , "value1"),
   ("key2" , "value2"),
   ("key3" , "value3")
)

循环输出上述Map中的键值数据的代码如下：

mp.keys.foreach {
   i =>
      print("Key = "+i)
      println(" Value = "+mp(i))
}

也可以使用for循环代替：

for((k,v)<-mp){
   println(k+":"+v)
}

2．可变Map

创建可变Map需要引入类scala.collection.mutable.Map，创建方式与上述不可变Map相同。

如果要访问Map中key1的值，代码如下：

val mp = Map(
   ("key1" , "value1"),
   ("key2" , "value2")
)
println(mp("key1"))

若键key1不存在则返回-1：

if(mp.contains("key1"))
    mp("key1")
else
    -1

上述代码也可以使用getOrElse()方法代替，该方法第一个参数表示访问的键，第二个参数表示若值不存在，则返回的默认值：

mp.getOrElse("key1", -1)

若要修改键key1的值为value2，代码如下：

mp("key1")="value2"

上述代码中，当key1存在时执行修改操作，若key1不存在，则执行添加操作。

当然，向Map中添加元素也可以使用+=符号，代码如下：

mp+=("key3" -> "value3")

或

mp+=(("key3","value3"))

相对应的，从Map中删除一个元素可以使用-=符号，代码如下：

mp-="key3"

1.4.4 元组

元组是一个可以存放不同类型对象的集合，元组中的元素不可以修改。

1．定义元组

例如，定义一个元组t：

val t=(1,"scala",2.6)

也可以使用以下方式定义元组，其中Tuple3是一个元组类，代表元组的长度为3：

val t2 = new Tuple3(1,"scala",2.6)

目前，Scala支持的元组最大长度为22，即可以使用Tuple1到Tuple22。元组的实际类型取决于元素数量和元素的类型。例如，(20,"shanghai")的类型是Tuple2[Int,String]，(10,20,"beijing","shanghai","guangzhou")的类型是Tuple5[Int,Int,String,String,String]。

2．访问元组

可以使用方法_1、_2、_3访问其中的元素。例如，取出元组中第一个元素：

println(t._1)

与数组和字符串的位置不同，元组的元素下标从1开始。

3．迭代元组

使用Tuple.productIterator()方法可以迭代输出元组的所有元素：

val t = (4,3,2,1)
t.productIterator.foreach{ i =>println("Value = " + i )}

4．元组转为字符串

使用Tuple.toString()方法可以将元组的所有元素组合成一个字符串：

val t = new Tuple3(1, "hello", "Scala")
println("连接后的字符串为: " + t.toString() )

上述代码输出结果为：

连接后的字符串为: (1,hello,Scala)

1.4.5 Set

Scala Set集合存储的对象不可重复。Set集合分为可变集合和不可变集合，默认情况下，Scala使用的是不可变集合，如果要使用可变集合，就需要引用scala.collection.mutable.Set包。

1．集合定义

可以使用如下方式定义一个不可变集合：

val set = Set(1,2,3)

2．元素增减

与List集合一样，对于不可变Set进行元素的增加和删除实际上会产生一个新的Set，原来的Set并没有改变，代码如下：

//定义一个不可变set集合
val set = Set(1,2,3)
//增加一个元素
val set1=set+4
//减少一个元素
val set2=set-3
println(set)
println(set1)
println(set2)

上述代码输出结果如下：

Set(1, 2, 3)
Set(1, 2, 3, 4)
Set(1, 2)

3．集合方法

常用的集合方法如下：

val site = Set("Ali", "Google", "Baidu")
//输出第一个元素
println(site.head)
//取得除了第一个元素外所有元素的集合
val set2=site.tail
println(set2)
//查看元素是否为空
println(site.isEmpty)

使用++运算符可以连接两个集合：

val site1 = Set("Ali", "Google", "Baidu")
val site2 = Set("Faceboook", "Taobao")
val site=site1++site2
println(site)

上述代码输出结果为：

Set(Faceboook, Taobao, Google, Ali, Baidu)

使用Set.min方法可以查找集合中的最小元素，使用Set.max方法可以查找集合中最大的元素，代码如下：

val num = Set(5,8,7,20,10,66)
//输出集合中的最小元素
println(num.min)
//输出集合中的最大元素
println(num.max)

你可以使用Set.&方法或Set.intersect方法查看两个集合的交集元素，代码如下：

val num1 = Set(5,2,9,10,3,15)
val num2 = Set(5,6,10,20,35,65)
//输出两个集合的交集元素
println(num1.&(num2))
//输出两个集合的交集元素
println(num1.intersect(num2))

上述代码输出结果为：

Set(5, 10)
Set(5, 10)