Scala基础 -- 3.数组、映射、元组、集合
3 数组、映射、元组、集合
3.1 数组
3.1.1 定长数组和变长数组
（1）定长数组定义格式：val arr=new Array[T](数组长度) 或val arr=Array[T](元素…)
（2）变长数组定义格式： val arr = ArrayBuffer[T]()
注意需要导包：import scala.collection.mutable.ArrayBuffer
//初始化一个定长数组,new出来的并且括号中赋值数组，相当于调用了数组的apply方法，直接为数组赋默认值，这里为0
val arr1 = new Array[Int](8)
//直接打印定长数组，内容为数组的hashcode值
println(arr1)
//将数组转换成数组缓冲，就可以看到原数组中的内容了,toBuffer会将数组转换长数组缓冲
println(arr1.toBuffer)
//初始化一个定长数组，自己指定值
//这里没用new，为自己赋值，这里是长度为1的数组，值为10
val arr2 = Array[Int](10)
println(arr2.toBuffer)
//定义一个长度为3的定长数组
val arr3 = Array[String]("Hello", "World", "Scala")
//使用下标来访问数组中元素
println(arr3(1))
/********************变长数组 *****************************/
//变长数组（数组缓冲）
//如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
val array4 = ArrayBuffer[Int]()
//+=向数组缓冲的尾部追加一个元素
array4 += 1
println(array4)
//尾部追加多个元素
array4 += (2, 3, 4, 5)
println(array4)
//追加一个数组,追加数组和数组缓冲需要用 ++=
array4 ++= Array(6, 7)
println(array4)
//追加一个数组缓冲，需要用++=
array4 ++= ArrayBuffer(8, 9)
println(array4)
array4.insert(0, -1, 0)
println(array4)
//删除数组某个位置的多个元素用remove
//从第9个位置删除两个元素
array4.remove(9, 2)
println(array4)
3.1.2 遍历数组
val array5 = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
//增强for输出
for (i <- array5) print(i + ",")
println()
//until循环赋值
for (i <- (0 until array5.length)) print(array5(i) + ",")
println()
3.1.3 数组转换
//将原数组的每个元素乘以10放入一个新的数组，yield把每个元素做对应操作后放入一个新的数组
val res = for (i <- array5) yield i * 10
println(res.toBuffer)
//取原数组元素中的偶数+10放入一个新的数组，在for中加if过滤
val res1 = for(i <- array5 if i % 2 == 0) yield i * 10
println(res1.toBuffer)
//更高级的写法,filter过滤，接收一个返回值为boolean的函数
//_下划线表示每次取出的元素
//map相当于将数组中的每一个元素取出来，应用传进去的函数
val res2 = array5.filter(_ % 2 == 0).map(_ * 10)
println(res2.toBuffer)
3.1.4 数组常用算法
//求和
println(array5.sum)
//求最大值
println(array5.max)
//数组排序，正序
println(array5.sorted.toBuffer)
//数组排序，倒序
println(array5.sorted.reverse.toBuffer)
3.2 映射
3.2.1 映射的声明
//在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变
//(1)不可变的Map import scala.collection.immutable._
// 创建map的第一种方式，用箭头
val map1 = Map("zhangsan" -> 18, "lisi" -> 20)
println(map1)
//创建map的第二种方式，用元组
val map2 = Map(("zhangsan", 20), ("lisi", 18))
println(map2)
//通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），
//那么就意味着该变量的引用不可变，该引用中的内容是不是可变，取决于这个引用指向的集合的类型
//(2)可变的Map import scala.collection.mutable._
val user = HashMap("zhangsan" -> 20, "lisi" -> 18)
println(user)
3.2.2 不可变映射的操作
//获取和修改Map中的值,通过key获取map的value
println(map2("zhangsan"))
println(map2.get("lisi"))
println(map2.get("lisi").get)
//如果map中没有该key，则会报错，可以使用map.getOrElse(key, defalut)
//println(map2("wangwu"))
println(map2.getOrElse("wangwu", "null"))
//遍历map集合
//方法一：显示所有的key
val keys: Iterable[String] = map2.keys
println(keys)
for(i <- keys) println(i + "-->" + map2(i))
println()
//方法二：显示所有的key
val set: Set[String] = map2.keySet
println(set)
for(i <- set) println(i + "-->" + map2(i))
println()
//通过元组
for((i, j) <- map2) println(i + "-->" + j)
println()
//通过模式匹配
map2.foreach{
case (x, y) => println(x + "-->" + y)
}
3.2.3 可变映射的操作
//添加键值对
user += ("wangwu" -> 19)
println(user)
//添加多个键值对
user += (("zhaoliu", 22), "tianqi" -> 23)
println(user)
//更新键值对
user("zhangsan") = 15
println(user)
//更新多个键值对
user += ("zhangsan" -> 33, "lisi" -> 40)
user.put("wangwu", 40)
println(user)
//删除key
user -= ("zhangsan")
user.remove("lisi")
println(user)
3.3 元组
3.3.1 创建元组
* 映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值
* （1）元组是不同类型的值的聚集；对偶是最简单的元组。
* （2）元组表示通过将不同的值用小括号括起来，即表示元组
* 创建元组格式：val tuple=(元素,元素...)
*/
val t = ("hadoop", "storm", "spark")
println(t)
val t1 = ("hadoop", 3.14, 10, true)
println(t1)
3.3.2 获取元组的值
/**
* (1) 获取元组中的值格式：
* 使用下划线加脚标 ，例如 t._1 t._2 t._3
* 注意：元组中的元素脚标是从1开始的
*/
println(t1._3)
3.3.3 对偶元组转集合
/**
* 将对偶的集合转换成映射：
* 调用其toMap方法
*/
val t2 = Array(("tom", 20), ("jerry", 18))
println(t2.toMap)
3.3.4 拉链操作
/**
* 拉链操作
* 1.使用zip命令可以将多个值绑定在一起
* 如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数
* 2.如果其中一个元素的个数比较少，可以使用zipAll用默认的元素填充
*/
val t3 = Array("tom", "jerry", "hello")
val t4 = Array(18, 19)
println(t3.zip(t4).toList)
//拿一个wangwu来凑数，使hello有匹配到值20
println(t3.zipAll(t4, "wangwu", 20).toList)
3.4 集合
Scala的集合有三大类：序列Seq、Set、映射Map，所有的集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）
在Scala中列表要么为空（Nil表示空列表）,要么是一个head元素加上一个tail列表
list常用的操作符：
+: (elem: A): List[A] 在列表的头部添加一个元素
:: (x: A): List[A] 在列表的头部添加一个元素
:+ (elem: A): List[A] 在列表的尾部添加一个元素
++[B](that: GenTraversableOnce[B]): List[B] 从列表的尾部添加另外一个列表
::: (prefix: List[A]): List[A] 在列表的头部添加另外一个列表
3.4.1 List
(1)不可变的序列 import scala.collection.immutable._
(2)//创建一个不可变的集合
val list1 = List(1,2,3)
//另一种定义list方法
val list2 = 2 :: Nil
println("list2: " + list2)
//获取集合的第一个元素，head元素
val first = list1.head
println("first: " + first)
//获取tail列表
val tail = list1.tail
println("tail: " + tail)
//通过下标获取元素
val mid = list1(1)
println("mid: " + mid)
//如果 List 中只有一个元素，那么它的 head 就是这个元素，它的 tail 就是 Nil；
println(list2.head + "-->" + list2.tail)
//将0插入到list1的前面生成一个新的List
val list3 = 0 :: list1
println("list3: " + list3)
println("list3: " + list1.+:(0))
val list4 = 0 +: list1
println("list4: " + list4)
println("list4: " + list1.+:(0))
//将一个元素添加到lst1的后面产生一个新的集合
val list5 = list1 :+ 0
println("list5: " + list5)
println("list5: " + list1.:+(0))
//将2个list合并成一个新的List
val list6 = List(4,5,6)
println(list1 ++ list6)
println(list1.++(list6))
//将list6插入到list1前面生成一个新的集合
println(list6 ++ list1)
println(list1.:::(list6))
(2)可变的序列 import scala.collection.mutable._
(3)//构建一个可变列表，初始有3个元素1,2,3
val blist = ListBuffer[Int](1,2,3)
//创建一个空的可变列表
val blist1 = new ListBuffer[Int]
//向lst1中追加元素，注意：没有生成新的集合
blist1 += 4
blist1.append(5)
blist1.+=(6)
println("blist: " + blist)
println("blist1: " + blist1)
//将blist1中的元素追加到blist中， 注意：没有生成新的集合
blist ++= blist1
println("blist: " + blist)
//将blist和blist1合并成一个新的ListBuffer 注意：生成了一个集合
val blist2 = blist ++= blist1
println("blist2: " + blist2)
//将元素追加到blist的后面生成一个新的集合
val blist3 = blist :+ 4
println("blist3: " + blist3)
//从集合左侧删除元素,注意：没有生成新的集合
blist3 -= 4
println("blist3: " + blist3)
//删除一个集合列表
blist3 --= List(1,2)
println("blist3: " + blist3)
//删除一个集合列表,生成了一个新的集合
val blist4 = blist3 -- List(6,4)
println("blist4: " + blist4)
//把可变list 转换成不可变的list 直接加上toList
val blist5 = blist4.toList
println("blist5: " + blist5)
3.4.2 Set
Set代表一个没有重复元素的集合；将重复元素加入Set是没有用的，而且 Set 是不保证插入顺序的，即 Set 中的元素是乱序的。定义：val set=Set(元素,元素,…)
(1) 不可变的Set import scala.collection.immutable._
//定义一个不可变的Set集合
val set = Set(1,2,3,4,5)
//元素个数
println("元素个数： " + set.size)
//取集合最小值
println("集合最小值： " + set.min)
//取集合最大值
println("集合最大值： " + set.max)
//添加元素，生成新的set，原有set不变
println(set + 6)
val set1 = Set(1,2,6,7,8,9)
//两个集合的交集
println("交集：" + (set & set1))
//两个集合的并集
println("并集：" + (set | set1))
println("并集：" + (set ++ set1))
//返回第一个不同于第二个set的元素集合
println("差集：" + (set -- set1))
println("差集：" + (set &~ set1))
println("差集：" + set.diff(set1))
//计算符合条件的元素个数
println("符合条件的元素个数：" + set.count(_ > 2))
//取子set，包含头不包含尾)
println(set.slice(2, 5))
//迭代所有的子set，取指定的个数组合
set.subsets(3).foreach(x => println("当前子set: " + x))
(2) 可变的Set import scala.collection.mutable._
//定义一个可变的Set
val set2 = new HashSet[Int]()
//添加元素
set2.add(2)
set2.+=(3)
println("添加元素：" + set2)
//向集合中添加元素集合
println("添加集合：" + (set2 ++= Set(3,4,5)))
//删除一个元素
set2 -= 5
set2.remove(4)
println("删除元素：" + set2)