3.数组、映射、元组、集合
3.1数组
3.1.1定长数组和变长数组
object ArrayDemo {
def main(args: Array[String]):Unit = {
//初始化一个长度为8的定长数组，其所有元素均为0
//注意：如果new ，相当于调用了数组的apply方法，直接为数组赋值
val arr1 =new Array[Int](8)
//直接打印定长数组，内容为定长数组的hashcode值
println(arr1)
//将数组转成数组缓冲，就可以看到原数组中的内容了
//toBuffer会将数组转换成数组缓冲
println(arr1.toBuffer)//结果：ArrayBuffer(0, 0, 0, 0, 0, 0, 0, 0)
//定义一个长度为3的定长数组
var arr2 =Array("hadoop","spark","java")
//使用（）来访问数组
println(arr2(2))
//变长数组
//如果想使用数组缓冲，需要导入import.scala.collection.mutable.ArrayBuffer包
val ab = ArrayBuffer[Int]()
//向数组缓冲的尾部追加一个元素
ab +=1
//追加多个元素
ab +=(2,3,4,5)
//追加一个数组(得++=)
ab ++=Array(7,8)
//追加一个数组缓冲
ab ++=ArrayBuffer(19,20)
//在数组的某个位置插入元素
ab.insert(1,200,300)
//删除某个位置的元素用remove
ab.remove(2)
println(ab.toString())
}
}
3.1.2遍历数组
1.增强for循环
2.好用的until会生成脚标，0 until 10 包含0 不包含10 （包前不包后）
object ForArrayDemo {
def main(args: Array[String]):Unit = {
//初始化一个数组
val arr =Array("haha","xixixi","lalal")
//增强for
for( a <- arr){
println(a)
}
//好用的until会生成一个Range（范围）
//reverse是将前面生成的Range反转
for(a <- (0 until arr.length).reverse){
println(a)
}
}
}
3.1.3数组转换
yield关键字将原始数组进行转换会产生一个新的数组，原始数组不变
object ArrayYieldDemo {
def main(args: Array[String]):Unit = {
//定义一个数组
val arr =Array(1,3,4,5,6,7,8)
//将偶数取出之后乘以10之后，生成一个新的数组
val res =for (a <- arrif a %2 ==0)yield a *10
println(res.toBuffer)
//更高级的写法
//filter 是过滤，接受一个返回值为Boolean的函数(相当于带for循环的if，里面的"_"是每次被循环对象中的值)
//map 相当于将数组中的每一个元素取出来，应用传进去的函数
val res2 = arr.filter(_ %2 ==0).map( _ *10)
println( res2.toBuffer)
}
}
3.1.4数组中常用的算法
在Scala中，数组上的某些方法对数组进行相应的操作非常方便
3.2映射
在scala中，把哈希表这种数据结构叫做映射
3.2.1构建映射
第一种创建map的方式，用箭头
val map1 =Map("tom" ->85,"jerry" ->30)
第二种创建map的方式，用元组
val map2 =Map(("tom",85),("jerry",30))
3.2.2获取和修改映射中的值
直接通过key来获取，和java类似
val map2 =Map(("tom",85),("jerry",30))
println(map2("tom")) // 结果：85
利用好用的getOrElse（如果映射中有key对应的值就返回，没有的返回默认值，下面的 0 则为默认值）
val map2 =Map(("tom",85),("jerry",30))
val value = map2.getOrElse("haha",0)
println(value) //结果：0
注意：在scala中有两种map，一个是immutable包下的map，该map的内容不可变；
另一个是mutable包下的map，该map中的内容是可变的
注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内容是不是可变的，取决于这个引用指向的集合类型。
3.2.3创建元组
定义元组时用小括号将多个元素包起来，元素之间用逗号分隔，元素的类型可以不一样，元素个数可以任意多个
val t = ("jaja",19,Array(1,2),Map("tom" -> 34))
println(t._3)
3.2.4获取元组中的值
3.2.5将对偶的集合转换成映射
3.2.6拉链操作
zip命令可以将多个值绑定在一起
val names =Array("zhangsan","lisi","wangwu")
val sourse =Array(12,23,34,45)
val vl = sourse.zip(names)
val ns = names.zip(sourse)
println(vl.toBuffer) //结果：ArrayBuffer((12,zhangsan), (23,lisi), (34,wangwu))
println(ns.toBuffer) //结果：ArrayBuffer((zhangsan,12), (lisi,23), (wangwu,34))
注意：如果两个数组的元素个数不一致时，拉链操作后生成的数组数组的长度为较小的那个数组的元素个数
3.3集合
scala的集合有三大类：序列Seq（list）、集Set、映射Map，所有的集合都扩展自Iterable特质在scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区别）
3.3.1序列(list)
不可变的序列 import scala.collection.immutable._
在scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
9 :: List(5,2) “::” 操作符是将给定的头和尾创建一个新的列表
注意：::操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
object ImmutListDemo {
def main(args: Array[String]):Unit = {
//创建一个不可变的集合
val lst1 =List(1,2,3)
//将0插入到lst1的前面生成一个新的list(下面的方法都OK)
val lst2 =0 :: lst1
val lst3 = lst1.::(0)
val lst4 =0 +:lst1
val lst5 = lst1.+:(0)
println(lst1,lst2,lst3,lst4,lst5)//结果：(List(1, 2, 3),List(0, 1, 2, 3),List(0, 1, 2, 3),List(0, 1, 2, 3),List(0, 1, 2, 3))
//将一个元素添加到lst1的后面产生一个新的集合
val lst6 = lst1 :+3
println(lst6)//结果：List(1, 2, 3, 3)
val lst7 = lst1 ++ lst2
println(lst7)//结果：List(1, 2, 3, 0, 1, 2, 3)
//将lst2插入到lst1 的里面生成一个新的list
val lst8 = lst2 +: lst1
println(lst8)//结果：List(List(0, 1, 2, 3), 1, 2, 3)
//将lst2插入到lst1 的前面生成一个新的list
val lst9 = lst2 ++: lst1
println(lst9)//结果：List(0, 1, 2, 3, 1, 2, 3)
//将lst0插入到lst1 的前面生成一个新的list
val lst0 =List(4,5,6)
val lst10 = lst1.:::(lst0)
println(lst10)//结果：List(4, 5, 6, 1, 2, 3)
}
}
可变的序列 import scala.collection.mutable._
import scala.collection.mutable.ListBuffer
object MutListDemo {
def main(args: Array[String]):Unit = {
//构建一个可变列表，初始有3个元素1,2,3
val lst0 = ListBuffer[Int](1,2,3)
//创建一个空的可变的列表
val lst1 = ListBuffer[Int]()
//向lst1中追加元素，注意没有生成新的列表
lst1 +=5
lst1.append(6)
println(lst1)//结果：ListBuffer(5, 6)
//将lst0中的元素添加到lst1中，注意没有生成新的列表
lst1 ++= lst0
println(lst1)//结果：ListBuffer(5, 6, 1, 2, 3)
//将lst0 和lst1合并成一个新的ListBbuffer，注意生成了新的列表
val lst2 = lst0 ++ lst1
println("lst0="+lst0+"lst1="+lst1+"ls2="+lst2)
//结果：lst0=ListBuffer(1, 2, 3)lst1=ListBuffer(5, 6, 1, 2, 3)ls2=ListBuffer(1, 2, 3, 5, 6, 1, 2, 3)
//将元素追加到lst0的后面生成一个新的集合
val lst3 = lst0 :+5
println(lst3)//结果：ListBuffer(1, 2, 3, 5)
}
}
3.4 Set
不可变的Set
import scala.collection.immutable.HashSet
object ImmutSetDemo {
def main(args: Array[String]):Unit = {
val set1 =new HashSet[Int]()
//将元素和set1合成一个新的set，原set不变
val set2 = set1 + (4,5)
println(set2)//结果：Set(5, 4)
//set中的元素不能重复
val set3 = set2 ++Set(4,5,6)
println(set3)//结果：Set(5, 6, 4)
val set0 =Set(1,2,4) ++ set2
println(set0)//结果：Set(1, 2, 4, 5)
println(set0.getClass)//结果：class scala.collection.immutable.Set$Set4
}
}
可变的Set
object MutSetDemo {
def main(args: Array[String]):Unit = {
//创建一个可变的set
val set1 =new mutable.HashSet[Int]()
//向HashSet中添加元素
set1 +=1
set1.add(2)
set1 ++=Set(3,4,5)
println(set1)//Set(1, 5, 2, 3, 4)
//删除一个元素
set1 -=5
set1.remove(2)
println(set1)//Set(1, 3, 4)
}
}
3.5 Map(可变的)
import scala.collection.mutable
object MutMapDemo {
def main(args: Array[String]):Unit = {
val map1 =new mutable.HashMap[Int,String]()
//向map中添加元素
map1(1) ="hello"
map1 += ((2 ->"xixi"))
map1 += ((3,"lala"))
map1.put(5,"scala")
println(map1)//Map(2 -> xixi, 5 -> scala, 1 -> hello, 3 -> lala)
//从map中移除元素
map1 -=2
map1.remove(1)
println(map1)//Map(5 -> scala, 3 -> lala)
}
}
