Scala基础7——第7章：集合

最新推荐文章于 2022-04-19 14:43:26 发布

半臻（火白）

最新推荐文章于 2022-04-19 14:43:26 发布

阅读量152

点赞数

分类专栏： Scala 文章标签： Scala

本文链接：https://blog.csdn.net/qq_35556504/article/details/119828250

版权

Scala 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文详细介绍了Scala中的集合类型，包括不可变和可变的Seq、Set、Map，以及数组的创建、访问、遍历和修改。特别强调了不可变集合的特点，以及如何在不同集合间转换。此外，还涵盖了列表List的特性，如链表结构和操作，以及元组、多维数组、集合函数如过滤、映射、规约等。最后，讨论了队列和并行集合的概念。

摘要由CSDN通过智能技术生成

第7章集合

7.1 集合介绍

（1）Scala的集合有三大类：序列Seq、集Set、映射Map

Java的集合也有三大类，List、Set、Map。 List和Set同属于Collection的子类，

（2）在Scala中，几乎所有的集合类，都提供了可变和不可变的版本，分别位于以下两个包

不可变集合： scala.collection.immutable

可变集合： scala.collection.mutable

（3） Scala不可变集合：该集合对象不可修改，每次修改会返回一个新的对象。类似于java的String

（4）Scala可变集合，可以直接对原对象做修改，不会返回新的对象。类似于java中StringBuilder对象

不可变的类的继承关系

（1）Traversable -> Iterable

（2）Iterable->Set、Map、Seq

（3）Set-> HashSet、 ListSet

（3）Map -> hashMap 、SortedMap、 ListMap

（3）Seq -> IndexedSeq 、LinearSeq

（4）IndexedSeq -> Vector 、NumericRange、 Array 、String 、Range （顺序表）

（4）LinearSeq -> List 、Stream 、Queue 、Stack （链表）

可变的类的继承关系

和不可变的结构大同小异，多了StringBuilder, Buffer等。

7.2 数组

7.2.1 不可变数组

val arr1 = new Array[Int](10)
（1）new是关键字
（2）[Int]是泛型，如果存储任意，则写成[Any]
（3）（10）表示数组的大小

object Test01{
    def main(args:Array[String]):Unit={
        // 1 创建数组
        val arr:Array[Int] = new Array[Int](5)
        // 1 创建数组的另一种方式
        val arr2 = Array(12,34,52,32,97)
        
        // 2 访问元素
        println(arr(0))
        println(arr(1))
        println(arr(3))
        
        // 数组赋值
        // 数组的内容可以变，但是长度不能变
        arr(0) = 20
        
    }
}

注！为什么Java用的【】，但是Scala用的（），主要是因为Scala是完全面向对象的，arr(0)相等于调用一个方法，该方法的参数就是数组下标

用for循环进行数组遍历

object Test01{
    def main(args:Array[String]):Unit={
        
        val arr:Array[Int] = Array(12,34,52,32,97)
    	// 1)普通for循环遍历
        for( i <- 0 until arr.length){
            println(arr(i))
        }
        
        for(i <- arr.indices){
            // arr.indices等价于0 until arr.length
            println(arr(i))
        }
        
        // 2) 增强for循环
        for( elem <- arr){
            println(elem)
        }
        
        // 3) 迭代器
        val iter = arr.iterator
        while(iter.hashNext){
            print(iter.next())
        }
        
        // 4) 调用foreach方法
        arr.foreach( (elem:Int) => println(elem))
        arr.foreach(println)
        
       	println(arr.mkString("--")) // 通过--进行连接
    }
}

数组中添加元素

object Test01{
    def main(args:Array[String]):Unit={
   		val arr:Array[Int] = Array(12,34,52,32,97)
        
        // 4 添加元素最后的元素
        // 返回一个新的数组
        val newArr = arr.:+(73)
        newArr.foreach(println)
        
        // 添加到最前面
        val newArr2 = newArr.+:(30)
        newArr2.foreach(println)
        
        // 添加到最后面
        val newArr3 = newArr2 :+ 15
        newArr3.foreach(println)
        // 添加到最前面
        val newArr4 = 29 +: newArr3 
        newArr4.foreach(println)
        
        val newArr5 = 12 +： 29 +: newArr3 :+ 22
  		      
    }
}

7.2.2 可变数组

ArrayBuffer 是可变数组

import scala.collection.mutable.ArrayBuffer

object Test02{
    def main(args:Array[String]):Unit={
        // 1 创建可变数组
        val arr1:ArrayBuffer[Int] = new ArrayBuffer[Int]()
        
        val arr2 = ArrayBuffer(23,56,92)
        
        println(arr1.mkString("--"))
        println(arr2)
 
    
    	println(arr2(0)) //访问数组的元素
    	println(arr2(1))
        
        // 修改元素
        arr2(1) = 88
    }
}

给数组添加元素

import scala.collection.mutable.ArrayBuffer

object Test02{
    def main(args:Array[String]):Unit={
        val arr1:ArrayBuffer[Int] = new ArrayBuffer[Int]()
        
        val arr2 = ArrayBuffer(23,56,92)
        
       	// 添加元素
        val newArr1 = arr1 :+ 15
        println(newArr1)
        
        // 直接添加到arr1中 最后一个元素
        arr1 += 19
        println(arr1)
        
        // 添加到第一个元素
        77 +=： arr1
        println(arr1)
        
        // 添加元素
        arr1.append(36)
        arr1.prepend(59,11)
        arr1.insert(1, 99,22) //在index为1中添加99和22
        arr1.insertAll(2,newArr1) // 添加整个List
        arr1.appendAll(newArr1)
        arr1.prependAll(newArr1)
        
        // 删除元素
        arr1.remove(3) // 指定下标删除
        println(arr1)
        
        // 删除多个元素
        arr1.remove(0,10)
        
        arr1 -= 13 // 删除特定的元素，如果找不到则不做任何操作
        println(arr1)
    }
}

可变数组和不可变数组的转换

object Test02{
    def main(args:Array[String]):Unit={
        // 可变数组 => 不可变数组
        val arr:ArrayBuffer[Int] = ArrayBuffer(23,56,98)
        val newArr:Array[Int] = arr.toArray // 转换为不可变数组
        println(newArr.mkString("--"))
        
        
        // 不可变数组 => 可变数组
        val buffer:mutable.Buffer[Int] = newArr.toBuffer
        println(buffer)
    }
}

多维数组

最高只能到5维

object Test03_MulArray{
    def main(args:Array[String]):Unit={
        
        // 创建二维数组
        val array:Array[Array[Int]] = Array.ofDim[Int](2,3) // 2行3列
        
        // 访问数组
        array(0)(2) = 19
        array(1)(2) = 25
        println(array(0)(2))
        
        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){
            print(array(i)(j) + "\t")
            if( j == array(i).length - 1)
            	println()
        }
        
        array.foreach(line => line.foreach(println) )
        
        array.foreach(_.foreach(println))
    }
}

7.3 列表List

列表相当于链表。

数组相当于数组

7.3.1 不可变List

1）说明

object Test04{
    def main(args:Array[String]):Unit={
        // 1 创建一个List,List是一个抽象类
        val list1 = List(3,4,34,45,23,99)
        println(list1)
        
        // 打印下标为1的数据
        println(list1(1))
        // list(1) = 12 ！！报错，不可以更改
        
        // 遍历list
        list1.foreach(println)
        
        // 3 添加元素
        val list2 = list1.+:(10)//添加到前面
        val list22 = 10 +: list1
        
        val list3 = list1.:+(23)//添加到后面
        val list33 = list1 :+ 23
        
        // 添加到了最前面
        val list4 =  (51) :: list2 
        // Nil相当于空list， 然后前面添加一个13
        val list5 =  13 :: Nil
        val list7 = 17 :: 18 :: 19 :: Nil //创建新列表
        println(list7)
        
        // 合并列表, ::: 
        val list9 = list5 ::: list7
        println(list8)
        // 合并链表 ++ 
        val list10 = list5 ++ list7
        
        
    }
}

7.3.2 可变列表ListBuffer

object Test05{
    def main(args:Array[String]):Unit={
        // 1 创建可变列表
        val list1:ListBuffer[Int] = new ListBuffer[Int]()
        val list2 = ListBuffer(12,53,75)
        println(list1)
        println(list2)
        
        // 2 添加元素
        list1.append(20)
        list1.append(21,23)
        list2.prepend(20)
        
        list1.insert(1,19,22)// 在index为1添加19，22
        // 添加元素
        list1 += 25 += 11
        31 +=: 96 +=: list1
        31 +=: 96 +=: list1 += 11 += 12
        
        // 合并list
        val list3 = list1 ++ list2 //合并为第三个list
        println(list1)
        println(list2)
        
        list1 ++= list2 // list1会变化
        
        // 4 修改元素
        list2(3) = 30 //把下标为3的修改为30
        list2.update(0,98)// 把下标为0，设置为98
        println(list(2))
        
        // 5 删除元素
        list2.remove(2) // 删除下标为2的数
        list2 -= 25 //删除指定的值
    }
}

7.4 集合Set

Scala分为不可变集合，可变的集合。

默认使用不可变集合。要使用可变Set，则需要导入mutable.Set这个包

7.4.1 不可变集合

object Test06{
    def main(args:Array[String]):Unit={
        
        // 1 创建Set
        val set1 = Set(12,34,21,12,45,45)
        println(set1) //会对数据进行去重
        
        // 2 添加元素,Set是无序的
        val set2 = set1.+(20)
        println(set2)
        val set22 = set1 + 20
        println(set22)
        
        // 3 合并Set
        val set3 = Set(18,13,23,53,67,99)
        val set4 = set2 ++ set3
        
        // 4 删除元素
        val set5 = set3 - 13 // 删除13这个元素
        println(set5)
        
    }
}

7.4.2 可变集合

object Test07{
    def main(args:Array[String]):Unit={
        // 1 创建Set
        val set1:mutable.Set[Int] = mutable.Set(20,32,34,54,33)
        println(set1)//创建可变的Set
        
        // 2 添加元素
        val set2 = set1 + 11
        println(set2)
        
        set1 += 11 // 添加元素
        println(set1)
        set1.add(10) // 添加元素
        
        // 3 删除元素
        set1 -= 11 // 删除特定元素
        set.remove(11) //删除特定元素
        
        // 4 合并两个Set
        val set3 = mutable.Set(13,12,13,27)
        val set4 = set1 ++ set3
        println(set4) //并集
        
        set1 ++= set3 // 等价于 set1 = set1 ++ set3
        
        
    }
}

7.5 Map集合

键值对 key-value

7.5.1 不可变的Map

object Test08{
    def main(args:Array[String]):Unit={
        // 1 创建map
        val map1:Map[String, Int] = Map("a" -> 12, "b"->25 , "hello"->3 )
        println(map1)
        println(map1.getClass)
        
        // 2 遍历元素
        map1.foreach(println)
        map1.foreach( (kv:(String,Int))=>println(kv) )
        
        
        // 3 取map中所有的key或者value
        for( key <- map1.keys ){
            println(s"${key} --> ${map1.get(key)} ")
        }
        
        
        println(map1("a")) // 如果存在返回值，不存在返回空指针异常
        
        
        map1.get("a") //返回Some(12), 找不到时返回Nothing类，是为了保证get方法不会产生空指针异常
        println(map1.get("a").get) // 返回12
        println(map1.get("c").get) // 返回None
        println(map1.getOrElse("c",-1))// 有值返回值，没有值返回-1
        
    }
}

7.5.2 可变的Map

object Test09{
    def main(args:Array[String]):Unit={
        // 添加一个map
        val map:mutable.Map[String,Int] = mutable.Map("a" -> 12, "b"->25 , "hello"->3 )
        println(map1)
        println(map1.getClass)
        
        // 2 添加元素
        map1.put("c",5)
        map1.put("d",9)
        map += (("e",7))
        
        // 3 删除元素
        map1.remove("c") // 删除指定的key
        map -= ("d") // 删除指定的key
       	
        // 4 修改元素
        map.update("c",99) // 修改数据，如果不存在相当于插入
        map += (("c",98)) // 修改数据
        
        // 5 合并两个map
        val map2:Map[String,Int] = Map("d"->23, "e"-> 30 )
        val map3 = map1 ++ map2
        map1 ++= map2
        
        
        
    }
}

7.6 元组

1）

元组将多个无关的数据封装在一起

注意：元组中最大只能有22个元素

val map:mutable.Map[String,Int] = mutable.Map("a" -> 12, "b"->25 , "hello"->3 )

"a" -> 12 // 其本质就是一个二元组，即（"a",12)

2）声明方式

(元素1, 元素2, 元素3 )

object Test10{
    def main(args:Array[String]):Unit={
        // 1 创建元组
        val tuple = ("hello",100,'a',true)//不需要定义类型
        println(tuple)
        
        // 2 访问数据
        println(tuple._1)//下标从1开始
        println(tuple._2)
        println(tuple._3)
        println(tuple._4) 
        // 访问数据
        println(tuple.productElement(0)) //下标从0开始
        
        // 3 遍历元组数据
        for( elem <- tuple.productIterator ){
            println(elem)
        }
        
        // 4 嵌套元组
        val mulTuple = (12, 0.3 , "hello" , (32,"scala"), "name")
        println(mulTuple._4._2)
               
    }
}

7.7 集合常用函数

7.7.1 基本属性和常用操作

1）集合的长度

2）集合的大小

3）遍历循环

4）迭代器

5）生成字符串

6）是否包含

object Test11{
    def main(args:Array[String]):Unit={
        val list = List(1,3,4,5,2,89)
        val set = Set(23,43,53,56)
        
        // 获得集合的长度
        println(list.length)
        
        // 获取集合的大小
        println(set.size)
        
        // 循环遍历
        for( elem <- list){
            println(elem)
        }
        set.foreach(println)
        
        // 迭代器
        for (elem <- list.iterator )
        	println(elem)
        
        // 生成字符串
        println(list)
        println(set)
        println(list.mkString("--"))
        
        // 是否包含
        println(list.contains(89))
        println(set.contains(23))
        
    }
}

7.7.2 衍生集合

1）获得集合的头

2）获取最后一个元素

3）反转

4）取前n个元素

8）并集、交际、差集

9）拉链

10）滑窗

object Test12{
    def main(args:Array[String]):Unit={
        
        val list1 = List(1,3,4,5,2,89)
        val list2 = List(2,3,4,3,2,99)
        
        // (1)获取集合的头
        println(list1.head) // 1
        
        // (2)获取集合的尾， 除了第一个。剩下的都是尾
        println(list1.tail)
        // 输出结果
        // List(3,4,5,2,89)
        
        // (3)获取最后一个元素
        println(list1.last) // 89
        
        // (4)集合初始数据（不包含最后一个元素）
        println(list1.init)
        
        // (5)反转
        println(list.reverse)
        
        // (6) 取前n个元素，后n个元素
        println(list1.take(3)) // 前3个元素
        println(list1.takeRight(4)) // 后4个元素
        
       // (7) 去掉前n个元素
        println(list1.drop(3))
        println(list1.dropRight(4))// 去掉后4个元素
        
        // (8) 并集
        // 如果是list不会去重， 等价于::: 等价于++
        // 如果是Set会去重
        val union = list1.union(list2)
        println(union) 
        
        // (9) 交集
        // 获取公共的部分
        val intersection = list1.intersect(list2)
        
        // (10) 差集
        val diff1 = list1.diff(list2)
        val diff2 = list2.diff(list1)
        
        // (11) 拉链 zip
        // 变成一个个的二元组
        println(list1.zip(list2))
        // List((1,3),(3,7),(5,2))
        
        // (12) 滑窗， 
        list1.sliding(3)// 得到大小的为3的窗口
        for (elem <- list1.sliding(3)){
            println(elem)
        }
        //  List(1,3,4,5,2,89)
        // 输出结果
        // List(1,3,4)
        // List(3,4,5)
        // List(4,5,2)
        // List(5,2,89)
        
        list1.sliding(3,2) //窗口大小为3，步长为2
        // List(1,3,4,5,2,89)
        // 输出结果
        // List(1,3,4)
        // List(4,5,2)
        // List(2,89)
        // 注：如果最后长度不够，还是会输出，保证所有的数据都显示出来
    }
}

7.7.3 集合计算简单函数

1）说明

求和、求成绩、最大值、最小值、排序

object Test13{
    def main(args:Array[String]):Unit={
        val list = List(5,1,8,2,-3,4)
        val list2 = List(("a",5),("b",1),("c",2),("d",2))
        
        // (1)求和
        println(list.sum)
        
        // (2)求乘积
        println(list.product)
        
        // (3)最大值
        println(list.max)
        
        println(list2.maxBy( (tuple:(String,Int)) => tuple._2 )) // 指定规则,求最大值,规定元组的第二个
        println(list2.maxBy( _._2 )) // 按照元组的第二个元素进行排序
        
        
        // (4)最小值
        println(list.min)
        println(list2.minBy(_._2))
        
        // (5)排序
        val sortedList = list.sorted
        println(sortedList) //进行排序
        
        // 逆序排序
        val reverseList =  list.sorted(Ordering[Int].reverse)
        
        // 对list2进行排序
        // val list2 = List(("a",5),("b",1),("c",2),("d",2))
        val list5 = list2.sortBy(_._2) // 按照第二个字段进行排序
        val list6 = list2.sortBy(_._2)(Ordering[Int].reverse)//逆序排序
        
        val list7 = list2.sortWith((a:Int,b:Int) => { a < b} ) // 如果a<b交换，则不需要交换。
        val list8 = list2.sortWith( _ < _ )
        val list9 = list2.sortWith( _ > _ ) //倒序排序
        
    }
}

7.7.4 集合计算高级函数

1）过滤

2）转换/映射（map）

3）扁平化 (flat)

4）扁平化+映射（flatMap)

5）分组(group)

按照指定的规则对集合的元素进行分组

6）简化（规约）

7）折叠

Map类的高级计算函数

object Test15{
    def main(args:Array[String]):Unit={
        
        val list = List(1,2,3,4,5,6,7,8,9)
        
        // 1 过滤
        // 选取偶数
        val evenList = list.filter( (elem:Int) => { elem % 2 ==0 } )
        val evenList2 = list.filter( _ % 2 ==0)
        
        // 选取奇数
        println(list.filter( _ % 2 == 1))
        
        // 2 map 集合的映射关系
        // 把集合中每个数乘以2
        println(list.map((elem:Int)=>{elem*2}))
        println(list.map( _ * 2 ))
        println(list.map( x => x*x )) //取平方
        
        // 扁平化
        // 把嵌套的list给压平
        val nestedList:List[List[Int]] = List(List(1,2,3),List(3,4,5),List(5,7,3,9))
        val flatList = nestedList(0) ::: nestedList(1) ::: nestedList(2) // 方法1
        println(flatList)
        
        val flatList2 = nestedList.flatten// 进行压平
        println(flatList2)
        
        // 4 扁平化 + 映射
        // 先扁平化，然后对每个元素进行映射
        // 将一组字符串进行分词，并保存成单词的列表
        val strings:List[String] = List("hello world","hello scala","hello java","we study")
        val splitList = strings.map( x => x.split(" ") ) // 对每个元素进行分割
        val flattenList = splitList.flatten //扁平化
        println(flattenList)
        // 先进行分割，然后再进行扁平化
        val flatmapList = strings.flatMap(_.split(" "))
        
        
        // 5 分组groupBy
        // 分成奇偶两组
        val groupMap = list.groupBy( _ % 2 )
        val groupMap2 = list.groupBy( data => {if(data%2==0) "偶数" else "奇数" })
        println(groupMap) 
        println(groupMap2) // 奇数->List(1,3,5,7) 偶数->List(2,4,6,8)
        
        
        // 给定一组词汇，按照单词的首字母进行分组
        val wordList = List("china","america","canda","carry","bob")
        println(wordList.groupBy( _.charAt(0) ))

    }
}

Reduce类的操作

object Test15{
    def main(args:Array[String]):Unit={
        val list = List(1,2,3,4)
        
        // 1 reduce
        // 累加求和
        val res1 = list.reduce( (a:Int,b:Int)=> a+b )
        val res2 = list.reduce( _ + _ )
        val res3 = list.reduceLeft( _ + _) //和reduce等价，都是从左往右规约
        val res4 = list.reduceRight( _ + _) //从右往左规约
        
        
        val list2 = List(3,4,5,8,10)
        val res5 = list.reduce( _ - _ ) // -24
        val res6 = list.reduceRight( _ - _ )
        // 3 - (4 - (5 - (8 - 10)))
        // res5 和 res6结果不一样。
        
        
        // 2 fold 
        // fold是reduce的扩展，设定一个初始值
        println(list.fold(10)(_ + _)) // 设定一个初始值10，  10 + 1 + 2 + 3 + 4
        println(list.foldLeft(10)(_ - _))//相当于[10,1,2,3,4]进行reduceLeft操作 
        // 10 - 1 -2 - 3 - 4
        println(list.foldRight(11)(_ - )) // 相当于[1,2,3,4,11] 进行reduceRight操作
         
    }
}

应用案例：合并Map

object Test16{
    def main(args:Array[String]):Unit={
        // 计算map1,map2的单词求和
        // 输出结果: Map(a->7,b->5,c->15,d->3)
        val map1 = Map("a"->1 , "b"->3, "c"->6)
        val map2 = mutable.Map("a"->6 , "b"->2, "c"->9 , "d"->3 )
        // println(map1 ++ map2) //不符合要求 
        // 输出结果
        // Map(a ->6 , b->2 , c->9 ,d->3)
        
        // 把初始值设置为map2, 然后用reduce一点一点操作
        val map3 = map1.foldLeft(map2)(
        	(mergedMap , kv ) => {
                val key = kv._1
                val value = kv._2
                
                mergedMap(key) = mergedMap.getOrElse(key,0) + value 
                mergedMap // 返回mergedMap
                
            }
        )
        
        
    }
}

7.7.5 普通WordCount案例

object Test17{
    def main(args:Array[String]):Unit={
        
        val stringList:List[String] = List("hello","hello world","hello scala","hello spark","hello spark from scala","hello flink")
        
        // 1 对字符串进行切割,并且扁平化
        val wordList1 = stringList.map( _.split(" "))
        val wordList2 = wordList1.flatten
        
        // 等价于
        val wordList = stringList.flatMap(_.split(" "))
        
        // 2 相同的单词进行分组, 对自己进行分组
        // 不可以用 _ 简化，因为编译器会混淆
        val groupMap = wordList.groupBy( word => word )
        
        // 3 进行规约操作
        val countMap = groupMap.map( kv => (kv._1 , kv._2.length))
        
        // 4 根据count值进行排序,并取前3个
        // 降序排列
        val sortList:List[(String,Int)] = countMap.toList.sortWith( _._2 > _._2 ).take(3)
        println(sortList)

    }
}

7.7.6 复杂版的WordCount

object Test18{
    def main(args:Array[String]):Unit={
        val tupleList:List[(String,Int)] = List(
        	("hello",1),
            ("hello world",2),
            ("hello scala",3),
            ("hello spark from scala",1)
        )
        
        // 思路一：直接展开为普通版本
        val newStringList = tupleList.map(
        	kv = {
                kv._1.trim + ' ' * kv._2 // 字符串的乘法
            }
        )
        // 接下来操作与普通版本完全一致
        val wordCountList:List[(String,Int)] = newStringList
        .flatMap(_.split(" ")) // 分割，打散
        .groupBy(word=>word) // 分组
        .map( kv => (kv._1,kv._2.length))
        .toList.sortBy(_._2)(Ordering[Int].reverse)
        .take(3)
        
        
        // 思路二：基于与统计的结果进行转换
        //("hello",1),
        //("hello world",2),
        //("hello scala",3),
        //("hello spark from scala",1)
        // 转换为
        //("hello",1) ("hello",2) ("world",2) ("hello",3) ("scala",3) ....
        val preCountList:List[(String,Int)] = tupleList.flatMap(
        	tuple =>{
                val strings:Array[String] = tuple._1.split(" ") // 进行分割
                strings.map( x => (x,tuple._2))
            }
        )
        // 对二元组进行分组
        // Map("hello"-> List(("hello",1),("hello",2),("hello",3)) )
        val preCountMap = preCountList.groupBy( _._1 )
        // 进行规约操作 reduce操作
        // mapValues对每一个值进行操作
        val countMap:Map[String,Int] = preCountMap.mapValues( 
        	tupleList => tupleList.map(_._2).sum
        )
        println(countMap)
		// 转换成List，排序取前3
        val countList = countMap.toList.sortWith(_._2 > _._2 ).take(3)
        println(countList)
    }
}

7.8 队列

1）先进先出 FIFO

object Test19{
    def main(args:Array[String]):Unit={
        // 创建一个可变队列
        val queue = new mutable.Queue[String]()
        
        // 入队
        queue.enqueue("a","b","c","d")
        
        println(queue)
        // 出队
        print(queue.dequeue())
        queue.dequeue()
        
        queue.enqueue("e")
        
        // 不可变队列
        val queue2:Queue[String] = Queue("a","b","c","d")
        // queue2.enqueue("a") 不会改变值
        val queue3 = queue2.enqueue("d") // 需要接收值
        
        
    }
}

7.9 并行集合

Scala充分利用多核CPU，提供了并行集合，用户多核环境的并行计算。

object Test20{
    def main(args:Array[String]):Unit={
        val result = (1 to 100).map(
        	x => Thread.currentThread.getName
        )
        println(result)
        // 输出结果
        // Vector(main,main,main,mian,....,main)
        
        // 通过添加par，获得不同的线程
        val result2 = (1 to 100).par.map(
        	x => Thread.currentThread.getId //获得对应的线程ID
        )
        // 输出结果
        // Vector(20,20,33,35,...,26)

    }
}