Scala入门(四)集合框架

• 数组
• 序列 List
• 映射 Map
• 集 Set
• Option

Scala的集合有三大类:序列Seq、集Set、映射Map,实现Iterable特质(类似接口)
集合有可变（mutable）和不可变（immutable）两种类型;
默认是不可变 scala.collection.immutable ;如果需要使用可变集合,手动导包 scala.collection.mutable
immutable 类型集合初始化后内容不能改变,而val 指的是变量的引用不可变

集合框架

1. 数组

1.1 定长数组和变长数组

定长数组: Array 长度不可变,内容可变
变长数组: ArrayBuffer 长度,内容均可变

创建定长数组:

val arr1 = Array[Int](1,2,3,45)   //类型可省略
val arr2 = new Array[Int](10)   //需指定数组类型和长度

取值与赋值,下表从0开始:

arr1(0)  //取值
arr1(0)=100 //赋值

打印数组:

println(arr1)  //打印hashcode
println(arr1.toBuffer) //转换成数组缓冲(变长数组),可查看其内容

---

创建变长数组:

import scala.collection.mutable.ArrayBuffer  //先导包
val ab = ArrayBuffer[Int](1,3,4)
val ab = new ArrayBuffer[Int]()

变长数组操作:

ab += 1  //+=尾部追加元素
ab += (2, 3, 4, 5)  //追加多个元素
ab -= (3, 4)
ab ++= Array(6, 7)   //追加一个数组++=
ab ++= ArrayBuffer(8,9)   //追加一个数组缓冲
ab --= Array(6, 7)   //减少一个数组++=
ab.insert(0, -1, 0)   //在第一个参数位置处插入后面的所有可变参数
ab.remove(8, 2)   //删除第一个参数后的2个元素
ab.clear()   // 清空
println(ab)  //打印

1.2 数组转换

Array(1,2,3,4).toBuffer   //定长数组转换成变长数组
ArrayBuffer[Int](1,2,3,4).toArray  //变长数组转换成定长数组

1.3 常用方法

val newArr=for(e <- arr) yield e*2 //使用yield生成一个新数组
arr.map(_*2) //遍历
arr.sum  //求和
arr.max  //求最大值
arr.sorted  //排序
arr.reverse //反转
arr.slice(1,4)  //从第一个参数位置(包含)开始到第二个参数位置(不包含)

序列 List

不可变List : 长度，内容 都不可变 ; Array内容可变
可变ListBuffer : 长度，内容都可变
创建不可变List:

val list1= List[Int](1,2,3)
val list2 = 9::5::2::Nil // ::操作符是右结合的，该操作符就是将给定的头和尾创建一个新的列表

不可变列表的连接:

val lst2 = 0 :: lst1  // 0插入到lst1之前,产生一个新的集合
val lst4 = 0 +: lst1 // 0插入到lst1之前,产生一个新的集合
val lst6 = lst1 :+ 3 //3插入到lst1后面,产生一个新的集合
 val lst7 = lst1 ++ lst0   //将2个list合并成一个新的List
val lst8 = lst1 ++: lst0   //将2个list合并成一个新的List
val lst9 = lst1 ::: lst0   //将2个list合并成一个新的List
val lst10 = List.concat(lst1,lst0)   //将2个list合并成一个新的List

其他方法:

lst1.reverse   // 列表反转
lst1.head   // 列表头元素
lst1.tail   // 列表的尾列表

---

创建可变List:

import scala.collection.mutable._  //导包
val lb1 = ListBuffer[Int]() // 创建的同时可赋初值
val lb2 = new ListBuffer[Int]() // 类型必须显示指定

可变list操作:

lst1 += （4,6）//向lst1中追加元素，注意：没有生成新的集合
lst1.append(5)
val lst2 = lst0 ++ lst1  // lst0和lst1合并,生成一个新集合
lst0 ++= lst1  // lst1追加到lst0中,注意：没有生成新的集合
val lst3 = lst0 :+ 5  //将元素追加到lst0的后面生成一个新的集合
val lst4 = 5 +: lst0  //将元素追加到lst0的前面
lb2 -= (1,3)   // 去除元素
lb2 --= List(7,9)  // 去除元素
lb2.remove(1,2) //去除元素 第一个参数是下标，第二个参数的个数
lb2.isEmpty()  // 判断集合是否为空 

映射Map

不可变Map创建:

val mp1 = Map(("a",1),("b",2))
val mp2 = Map("a"->1,"b"->2)

不可变Map添加元素:

val mp3 = mp2+("c"->1) 

---

可变Map创建:

import scala.collection.mutable  //导包
val mp4 = new mutable.HashMap[String,Int]()
val mp5 = mutable.Map[String,Int]()

可变Map添加元素:

mp4 += ("a"->1, "b"->2)
mp4+= (("c",3))
mp4.put("d",4)
mp4("e")=5 

---

获取映射值:

mp4.contains(“a”)  //返回值 Boolean
mp4(“b”)  //获取key为b的value
mp4.get(“c”)  
mp4.getOrElse(“f”,6)  //获取key为f的value,如果key不存在,则默认显示为6

修改映射值:

m1.updated("b",22)  // 如果是不可变的Map,那么会生成一个新的map集合

删除元素:

m1 -= ("a")
m1.remove("a")
m1 -= ("a","b")  //删除多个key

遍历:

for(i <- mp) println(i)  
for((k,v) <- mp){println(k)}  
for((_,v) <- mp){println(v)}  
for((k,v) <- mp) yield (v,k)  //交换kv
mp.map(x=>(x._2,x._1))   //交换kv
mp.map(x=>x.swap)   //交换kv

获取keys和values:

m.keys
m.keySet
m.values

合并map:

val map1= Map("a" ->1,"b" -> 2)
val map2= Map("a" -> 3,"c" -> 4)
var map= map1++ map2    // Map("a" ->3,"b" -> 2,"c"->4) 合并时会虑重 去除键相同的元素,并且以新的值代替

Set

不可变Set:长度和值都不可变,元素不可重复
不可变Set创建:

val set1 = Set (1,2,3)

不可变Set添加删除:

val s2: Set[Int] = set1 + (4,5)
set1 - (1)

---

可变Set:长度和值均可改变,元素不重复
可变Set创建:

 import scala.collection.mutable.Set // 可以在任何地方引入 可变集合
val mSet = new mutable.HashSet[Int]()
val mutableSet = Set(1,2,3)

可变Set添加和删除:

mutableSet.add(4)
mutableSet += 5
mutableSet += (5,6)
mutableSet ++= Set(7,8)
mutableSet -= 9
mutableSet -= (9,10)
mutableSet.remove(1)  //移除的是1元素

可变Set转换成不可变Set:

val another = mutableSet.toSet

Option

Option 表示可以有值，也可能没有值的返回类型，有两个子类，
Some，有值的结果 Some(值) ,多例,样例类, 想要获取值，使用 get方法
None，没有值,单例,样例对象

val rv: Option[Int] = mp.get("d")  //可能有值,也可能无值
val r1 = rv.get  //如果rv为None,则会出现异常
val r2 = mp.getOrElse("d", -1)  //推荐使用,如果无值,返回默认值-1

集合的常用方法

map:遍历
filter:过滤满足条件的所有元素,返回集合
find:过滤出满足条件的一个元素,返回option
sorted:按元素升序排序
sortBy:按指定条件排序
sortWith:接收参数,进行比较
mapValues:类似map,只处理value
groupBy:按照指定条件分组
grouped:按元素个数进行分组
count:统计满足条件的元素个数
reduce:元素归并 reduceRight   val arr=Array("aa","bb","cc","dd"); arr.reduce(_ + _)   //aabbccdd
        参数是一个函数,该函数有两个参数  累加值 元素值
fold:两个参数 第一个参数是默认值,第二个参数是一个函数,该函数有两个参数,累加值 函数值
intersect :交集    union:并集    diff:差集
distinct:元素去重
mkString:所有元素拼成字符串   mkString(分隔符)
take(n):获取集合中前几个元素
slice(from ,util) 截取元素
aggregate:聚合

小练习

    println("计算一个Array[Double]数组的平均值")
    val arr1 = Array[Double](1, 2, 3, 4, 5)
    val res1: Double = arr1.sum / arr1.length
    println(res1)

    println("编写一个函数或方法，返回数组中最小值和最大值的对偶  （元组）")

    def test2(arr: Array[Double]) = (arr.max, arr.min)

    println(test2(arr1))
    val test22 = (arr: Array[Double]) => (arr.max, arr.min)
    println(test22(arr1))

    println("编写一个函数或方法，getValues(values: Array[lnt]，v：Int)，返回数组中小于v、等于v和大于v的元素个数，要求三个值一起返回")
    val getValues = (values: Array[Double], v: Double) => {
      val less = values.count(t => t - v < 0)
      val more = values.count(t => t - v > 0)
      val equal = values.count(t => t - v == 0)
      (less, more, equal)
    }
    println(getValues(arr1, 1))


    println("数组反转 Array(1,2,3,5,6,7,9)  2 1 5 3 7 6 9")
    val arr2 = Array(1, 2, 3, 5, 6, 7, 9)
    val iterator: Iterator[Array[Int]] = arr2.grouped(2)
    val res2: Iterator[Int] = iterator.flatMap(t => t.reverse)
    val res3: Array[Int] = res2.toArray
    println(res3.toBuffer)