Scala-day05-集合
一：集合简介
1：Scala的集合有三大类，序列seq、集set、映射Map，所有的集合都扩展自Iterable特质
2：对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。
可变集合：scala.collection.mutable
不可变集合：scala.collection.immutable
3：Scala不可变集合，就是指该集合对象不可修改，每次修改都会返回一个新对象，而不会对原对象进行修改。类似于Java中的string对象
4：可变集合，就是这个集合可以直接对原对象进行修改，而不返回新的对象。类似于Java中的string builder对象
二：数组
1：不可变数组-第一种定义
定义：val arr1 = new Array[Int](10)
new 是关键字
[Int] 是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any
(10)，表示数组的大小，确定后不可以变化
2：不可变数组：第二种定义
定义：val arr = Array(1,2)
在定义数组时，直接赋初始值
使用apply方法创建数组对象
3：不可变数组-案例
package chapter06
object Test01_ImmutableArray {
def main(args: Array[String]): Unit = {
//1.创建数组
val arr = new Array[Int](5)
// 另一种创建方式
val arr2 = Array(12,37,42,58,97)
//2.访问元素
println(arr(0))
println(arr(1))
println(arr(2))
//修改
arr(0)=12
arr(4)=57
println(arr(0))
println(arr(1))
println(arr(2))
//遍历
//普通for循环
for(i <- 0 until arr.length){
println(arr(i))
}
for(i <- arr.indices){
println(arr(i))
}
//直接遍历所有元素，增强for循环
for(elem <- arr2){
println(elem)
}
//迭代器
val iter = arr2.iterator
while (iter.hasNext){
println(iter.next())
}
// 调用foreach方法
arr2.foreach((elem:Int) => println(elem))
println(arr2.mkString("--"))//12--37--42--58--97
//添加元素
val newArr = arr2.:+(73)//后面添加
println(arr2.mkString("--"))//12--37--42--58--97
println(newArr.mkString("--"))//12--37--42--58--97--73
val newArr2 = newArr.+:(30)//前面添加
println(newArr2.mkString("--"))//30--12--37--42--58--97--73
val newArr3 = newArr2 :+ 15 //后面添加
val newArr4 = 29 +: newArr3 //前面添加
val newArr5 = 10 +: 29 +: newArr4 :+ 26 :+ 73
}
}
4：可变数组
val arr01 = ArrayBuffer[Any](3,2,5)
[Any]存放任意数据类型
（3，2，5）初始化好的三个元素
ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer
5：可变数组的案例
package chapter06
import scala.collection.mutable.{AbstractBuffer, ArrayBuffer}
object Test02_ArrayBuffer {
def main(args: Array[String]): Unit = {
//1.创建可变数组
val arr1 = new ArrayBuffer[Int]()
val arr2 = ArrayBuffer(23,57,92)
println(arr1.mkString(","))
println(arr2)
//访问元素
println(arr2(1))
arr2(1) = 39
println(arr2(1))
//添加元素
val newArr1 = arr1 :+ 15
println(arr1)
println(newArr1)
arr1 += 19//后面添加
println(arr1)
77 +=: arr1//前面添加
println(arr1)
arr1.append(36)//后面添加
arr1.prepend(11,76)//前面添加
arr1.insert(1,13,59)//具体位置来添加，第一个参数为索引位置
arr1.insertAll(2,newArr1) //索引为2的地方，添加一个数组
//删除元素
arr1.remove(3)//参数为索引位置
arr1.remove(0,10)//第一个参数为索引位置，第二个参数代表删除几个数
arr1 -= 13 //arr1中删除13的数据，如果没有出现过，也可以，代表什么也不操作
//可变数组转换为不可变数组
val arr = ArrayBuffer(23,56,98)
val newArr = arr.toArray
//不可变数组转换为可变数组
val buffer = newArr.toBuffer
}
}
6：多维数组
package chapter06
object Test03_MulArray {
def main(args: Array[String]): Unit = {
//创建二维数组
val array:Array[Array[Int]] = Array.ofDim[Int](2,3)//两行三列的二维数组
//访问元素
array(0)(2) = 19
array(1)(0) = 25
println(array.mkString(","))
for (i <- 0 until array.length; j <- 0 until array(i).length){
println(array(i)(j))
}
for (i <- array.indices; j <- array(i).indices){
println(array(i)(j) + "\t")
if (j == array(i).length-1)
println()
}
array.foreach(line => line.foreach(println))
array.foreach(_.foreach(println))
}
}
三：列表
可变列表和不可变列表
package chapter06
import scala.collection.mutable.ListBuffer
object Test05_ListBuffer {
def main(args: Array[String]): Unit = {
//创建可变列表
val list1 = new ListBuffer[Int]()
val list2 = ListBuffer(12,53,75)
println(list1)
println(list2)
//添加元素
list1.append(15,62)
list2.prepend(20)
list1.insert(1,19,22)
println(list1)
println(list2)
list1 += 25 += 11
31 +=: 96 +=: list1
println(list1)
val list3 = list1 ++ list2
println(list1)
println(list2)//list1和list2都不会发生改变
list1 ++= list2
println(list1)//list1发生改变，list2不发生改变
println(list2)
//修改元素
list2(3) = 30
println(list2)
//删除元素
list2.remove(2)
list2 -= 25
println(list2)
}
}
四：set集合（无序、不可重复）
不可变set集合
package chapter06
object Test06_ImmutableSet {
def main(args: Array[String]): Unit = {
//创建set
val set1 = Set(13,23,53,12,13,53,78)
println(set1)
//添加元素
val set2 = set1.+(20)//set1本身不变
println(set1)
println(set2)
//合并
val set3 = Set(19,13,23,53,67,99)
val set4 = set2 ++ set3
println(set4)
println(set2)
println(set3)
//删除元素
val set5 = set3 - 13
println(set5)
}
}
可变set集合
package chapter06
import scala.collection.mutable
object Test07_MutableSet {
def main(args: Array[String]): Unit = {
//创建set
val set1 = mutable.Set(13,23,53,12,13,23,78)
println(set1)
//添加元素
val set2 = set1 + 11
println(set1)
println(set2)
set1 += 11
println(set1)
set1.add(10)
println(set1)
//删除元素
set1 -= 11
println(set1)
//合并
val set3 = mutable.Set(13,12,13,27,98,29)
println(set1)
println(set3)
set1 ++= set3
println(set1)
}
}
五：Map集合
不可变Map
package chapter06
object Test08_ImmutableMap {
def main(args: Array[String]): Unit = {
//创建map
val map1:Map[String,Int] = Map("a" -> 12,"b" -> 25)
println(map1)
println(map1.getClass)
//遍历元素
map1.foreach(println)
map1.foreach( (kv:(String,Int)) => println(kv))
//map中所有的key或value
for (key <- map1.keys){
println(s"$key ---> ${map1.get(key)}")
}
//访问某一个key的value
println(map1.get("a").get)
println(map1.get("c"))
println(map1.getOrElse("c",0))//获取c的值，如果没有，返回初始值
}
}
可变Map
package chapter06
import scala.collection.mutable
object Test09_MutableMap {
def main(args: Array[String]): Unit = {
//创建map
val map1:mutable.Map[String,Int] = mutable.Map("a" -> 12,"b" -> 25)
println(map1)
println(map1.getClass)
//添加元素
map1.put("c",5)
map1.put("d",9)
println(map1)
map1 += (("e",7))
println(map1)
//删除元素
map1.remove("c")
map1 -= "d"
println(map1)
//修改元素
map1.update("a",5)
//合并
val map2:mutable.Map[String,Int] = mutable.Map("aa" -> 12,"bb" -> 25)
map1 ++= map2
println(map1)
val map3 = map2 ++ map1
println(map1)
println(map2)
println(map3)
}
}
六：元组
package chapter06
object Test10_Yuple {
def main(args: Array[String]): Unit = {
//创建元组
val tuple = ("hello",100,'a',true)
println(tuple)
//访问数据
println(tuple._1)
println(tuple._2)
println(tuple.productElement(1))//从0开始
//遍历元组数据
for (elem <- tuple.productIterator){
println(elem)
}
//嵌套元组
val mulTuple = (12,0.3,"hello",(23,"scala",29))
println(mulTuple._4._2)//scala
}
}
七：集合-通用属性和操作
package chapter06
object Test11_CommonOp {
def main(args: Array[String]): Unit = {
val list = List(1,3,5,7,2,89)
val set = Set(23,34)
println(list.length)
println(set.size)
for (elem <- list){
println(elem)
}
set.foreach(println)
for(elem <- list.iterator) println(elem)
//生成字符串
println(list.mkString("--"))
//是否包含
println(list.contains(23))
}
}
八：集合-衍生集合
package chapter06
object Test12_DerivedCollection {
def main(args: Array[String]): Unit = {
val list1 = List(1,3,5,7,9)
val list2 = List(3,7,2,4,8)
//获取集合的头
println(list1.head)
//获取集合的尾
println(list1.tail)//除了头全是尾
//集合最后一个元素
println(list2.last)
//集合初始元素（不包含最后一个）
println(list2.init)
//反转
println(list1.reverse)
//取前n个元素，后n个元素
println(list1.take(3))//前3
println(list1.takeRight(4))//后4
//去掉前后n个元素
println(list1.drop(3))
println(list1.dropRight(4))
//并集，如果是set会去重
val union = list1.union(list2)
println(union)
//交集
val intersection = list1.intersect(list2)
println(intersection)
//差集
val diff1 = list1.diff(list2)//属于list1，但不属于list2
val diff2 = list2.diff(list1)//属于list2，但不属于list1
//拉链
println(list1.zip(list2))//对应位置构成二元组
//滑窗
list1.sliding(3)//要得到大小为3的滑动窗口
for(elem <- list1.sliding(3)){
println(elem)
}
}
}
九：集合-简单函数
package chapter06
object Test13_SimpleFunction {
def main(args: Array[String]): Unit = {
val list = List(5,1,8,2,-3,4)
val list2 = List(("a",5),("b",1),("c",8),("d",2),("e",-3),("f",4))
//求和
var sum = 0
for(elem <- list){
sum += elem
}
println(sum)
println(list.sum)
//乘积
println(list.product)
//最大
println(list.max)
println(list2.maxBy( (tuple:(String,Int)) => tuple._2))
//最小
println(list.min)
//排序
val sortedList = list.sorted
println(sortedList)//从小到大
//从大到小
println(list.sorted(Ordering[Int].reverse))
println(list2.sortBy(_._2))
}
}
十：集合-高级计算函数-Map
package chapter06
object Test14_HighLevelFuntion_Map {
def main(args: Array[String]): Unit = {
val list = List(1,2,3,4,5,6,7,8,9)
//过滤--选取偶数
val evenList = list.filter( (elem:Int) => {elem % 2 ==0})
println(evenList)
//map
//把集合中的每个数乘2
println(list.maxBy(_*2))
println(list.map( x => x*x))
//扁平化
val nestList:List[List[Int]] = List(List(1,2,3),List(4,5),List(6,7,8,9))
val flatList = nestList(0):::nestList(1):::nestList(2)
println(flatList)
val flatList2 = nestList.flatten
println(flatList2)
//扁平映射
//将一组字符串进行分词，并博爱村成单词的列表
val strings:List[String] = List("hello world","hello scala","hello java","we study")
val splitList = strings.map(string => string.split(" "));
val flattenList = splitList.flatten //打散扁平化
println(flattenList)
val flatmapList = strings.flatMap(_.split(" "))
println(flatmapList)
//分组
//分成奇数偶数两组
val groupMap = list.groupBy( _ % 2)
val groupMap2 = list.groupBy( data => {
if (data % 2 ==0)
"偶数"
})
//给定一组词汇，按照单词的首字母进行分组
val wordList = List("china","america","canada","cary","bob")
println(wordList.groupBy( _.charAt(0)))
}
}
十一：集合-高级计算函数-Reduce/fold
package chapter06
object Test15_HighLevelFunction_Reduce {
def main(args: Array[String]): Unit = {
val list = List(1,2,3,4)
println(list.reduce( _ + _ ))
val list2 = List(3,4,5,6,8,10)
println(list2.reduce(_ + _))
println(list2.reduceLeft(_ + _))//从左向右减
println(list2.reduceRight(_ + _))//3-(4-(5-(8-10)))
//fold
println(list.fold(10)(_ + _)) //10+1+2+3+4
println(list.foldLeft(10)(_ - _)) //10-1-2-3-4
println(list.foldRight(11)(_ - _)) //3-(4-(5-(8-(10-11))))
}
}
package chapter06
import scala.collection.mutable
object Test16_MergeMap {
def main(args: Array[String]): Unit = {
val map1 = Map("a" -> 1,"b" -> 3,"c" -> 6)
val map2 = mutable.Map("a" -> 6,"b" -> 2,"c" -> 9,"d" -> 3)
val map3 = map1.foldLeft(map2)(
(mergedMap,kv) => {
val key = kv._1
val value = kv._2
mergedMap(key) = mergedMap.getOrElse(key,0)+value
mergedMap
}
)
}
}
十二：队列
package chapter06
import scala.collection.immutable.Queue
import scala.collection.mutable
import scala.collection.parallel.immutable
object Test18_Queue {
def main(args: Array[String]): Unit = {
//创建可变队列
val queue = new mutable.Queue()
//入队
queue.enqueue("a","b","c")
println(queue)
//出队
println(queue.dequeue())
//不可变队列
val queue2 = Queue("a","b","c")
println(queue2.dequeue)
}
}