Scala学习之路 （四）Scala的数组、映射、元组、集合

一、数组

1、定长数组和变长数组

import scala.collection.mutable.ArrayBuffer

object TestScala {
def main(args: Array[String]) {
//初始化一个长度为8的定长数组，其所有元素均为0
val arr1 = new Array[Int](8)
//直接打印定长数组，内容为数组的hashcode值
println("arr1="+arr1)
//将数组转换成数组缓冲，就可以看到原数组中的内容了
//toBuffer会将数组转换长数组缓冲
println("arr1.toBuffer="+arr1.toBuffer)
//注意：如果new，相当于调用了数组的apply方法，直接为数组赋值
//初始化一个长度为1的定长数组
val arr2 = Array[Int](10)
println("arr2.toBuffer="+arr2.toBuffer)
//定义一个长度为3的定长数组
val arr3 = Array("hadoop", "storm", "spark")
//使用()来访问元素
println("arr3(2)="+arr3(2))

//////////////////////////////////////////////////
//变长数组（数组缓冲）
//如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
var ab = ArrayBuffer[Int]()
//向数组缓冲的尾部追加一个元素
//+=尾部追加元素
ab += 1
//追加多个元素
ab += (2, 3, 4, 5)
//追加一个数组++=
ab ++= Array(6, 7)
//追加一个数组缓冲
ab ++= ArrayBuffer(8,9)
//打印数组缓冲ab

//在数组某个位置插入元素用insert
ab.insert(0, -1, 0)
//删除数组某个位置的元素用remove
ab.remove(8, 2)
println("ab="+ab)

}

}

运行结果

2、遍历数组

（1）增强for循环

（2）好用的until会生成脚标，0 until 10 包含0不包含10

def main(args: Array[String]) {
//初始化一个数组
val arr = Array(1,2,3,4,5,6,7,8)
//增强for循环
for(i <- arr)
print(i+"\t")

println()
//好用的until会生成一个Range
//reverse是将前面生成的Range反转
for(i <- (0 until arr.length).reverse)
print(arr(i))
}

3、数组转换

yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变

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

//更高级的写法,用着更爽
//filter是过滤，接收一个返回值为boolean的函数
//map相当于将数组中的每一个元素取出来，应用传进去的函数
val r = arr.filter(_ % 2 == 0).map(_ * 10)
println(r.toBuffer)

}

4、常用数组的算法

在Scala中，数组上的某些方法对数组进行相应的操作非常方便！

二、映射（Map）

在Scala中，把哈希表这种数据结构叫做映射

1、构建映射

2、获取映射中的值

getOrElse：有就返回对应的值，没有就返回默认值

注意：在Scala中，有两种Map，

一个是immutable包下的Map，该Map中的内容不可变；

另一个是mutable包下的Map，该Map中的内容可变 （val var）

注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型

1:是否可以修改值

Mutable  可以修改map里面的值

Immutable 不可以修改里面的值

2：是否可以追加元素

2.1  mutable var/val 都可以追加元素

2.2  imtable var 可以追加，val不可以追加

三、元组

映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。

1、创建元组

2、获取元组中的值

3、将对偶的元组转换成映射

4、拉链操作

zip命令可以将多个值绑定在一起

注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数

四、集合

Scala 集合类系统地区分了可变的和不可变的集合。可变集合可以在适当的地方被更新或扩展。这意味着你可以修改，添加，移除一个集合的元素。而不可变集合类，相比之下，永远不会改变。不过，你仍然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。

所有的集合类都可以在包

scala.collection

scala.collection.mutable

scala.collection.immutable

scala.collection.generic

scala.collection

scala.collection.immutable

scala.collection.mutable

scala.collection.immutable：

scala.collection.mutable：

scala.collection：

scala.collection

scala.collection.mutable

根集合类与不可变集合类之间的区别是不可变集合类的客户端可以确保没有人可以修改集合。然而，根集合类的客户端仅保证不修改集合本身。即使这个集合类没有提供修改集合的静态操作，它仍然可能在运行时作为可变集合被其它客户端所修改。

默认情况下，Scala 一直采用不可变集合类。例如，如果你仅写了

Set

Set

set

collection.mutable.Set

collection.mutable.Iterable

一个有用的约定，如果你想要同时使用可变和不可变集合类，只导入collection.mutable包即可。

import scala.collection.mutable  //导入包scala.collection.mutable

然而，像没有前缀的Set这样的关键字， 仍然指的是一个不可变集合，然而

mutable.Set

集合树的最后一个包是

collection.generic

collection.generic

collection.generic

为了方便和向后兼容性，一些导入类型在包scala中有别名，所以你能通过简单的名字使用它们而不需要import。这有一个例子是List 类型，它可以用以下两种方法使用，如下：

scala.collection.immutable.List // 这是它的定义位置
scala.List //通过scala 包中的别名
List // 因为scala._ // 总是是被自动导入。

下面的图表显示了

scala.collection

下面的图表显示scala.collection.immutable中的所有集合类。

下面的图表显示scala.collection.mutable中的所有集合类。

Seq

不可变的序列 import scala.collection.immutable._

在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。

9 :: List(5, 2)  :: 操作符是将给定的头和尾创建一个新的列表

注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

def main(args: Array[String]): Unit = {
//创建一个不可变集合
val list1 = List(1,2,3)
//将0插入到集合list1的前面生成一个新的list
val list2 = 0 :: list1
val list3 = list1.:: (0)
val list4 = 0 +: list1
val list5 = list1. +: (0)
println("list2=" + list2)
println("list3=" + list3)
println("list4=" + list4)
println("list5=" + list5)

//将3插入到集合list1的后面生成一个新的list
val list6 = list1 :+ 3
println("list6="+list6)

//将2个list集合合并成一个新的list集合
val list0 = List(7,8,9)
println("list0="+list0)
val list7 = list1 ++ list0
println("list7="+list7)

//将list0插入到list1前面生成一个新的集合
val list8 = list0 ++: list1
println("list8="+list8)

//将list1插入到list0前面生成一个新的集合
val list9 = list1 ++: list0
println("list9="+list9)

}

可变的序列 import scala.collection.mutable._

def main(args: Array[String]): Unit = {
//构建一个可变序列
val list1 = ListBuffer[Int](1,2,3)
//创建一个空的可变序列
val list2 = new ListBuffer[Int]
//向list2中追加元素，注意：没有生成新的集合
list2 += 6
list2.append(7)
println("list2=" + list2)

//将list2中的元素追加到list1中，注意：没有生成新的集合
list1 ++= list2
print("list1=" + list1)

//将list1和list2合并成一个新的list集合，注意：生成新的集合
val list3 = list1 ++ list2
println("list3=" + list3)

//将元素追加到list1后面生成一个新的集合
val list4 = list1 :+ 9
print("list4=" + list4)

}

Set

不可变的Set

def main(args: Array[String]): Unit = {
//创建一个空的set
val set1 = new HashSet[Int]()
println("set1=" + set1)
//将元素和set合并生成一个新的set，原有set不变
val set2 = set1 + 4
println("set2=" + set2)
//set中元素不能重复
val set3 = set1 ++ Set(5,6,7)
println("set3=" + set3)
val set4 = Set(4,3,2) ++ set2
println("set4=" + set4)
}

可变的Set

def main(args: Array[String]): Unit = {
//创建一个可变的set
val set1 = new mutable.HashSet[Int]()
println("list1=" + set1)
//向set1中添加元素
set1 += 4
//add等价于+=
set1.add(5)
set1 ++= Set(6,7,8)
println("set1="+set1)
//删除一个元素
set1 -= 8
set1.remove(7)
println("set1=" + set1)

}