拉链（zip）
拉链操作（Zip）是一种将两个集合合并为一个对偶集合的操作。这个操作会创建一个新的集合，其中的每个元素都是由两个原始集合对应位置上的元素组成的对偶。拉链操作适用于两个集合长度相同的情况。
val a=List("scala","java")
val b=List(10,20)
val c=a.zip(b)
for(i<-c){
println(i._1,i._2)
}
/*
(scala,10)
(java,20)
*/遍历（foreach）
foreach 是一个用于集合的迭代操作的方法，它接收一个函数作为参数，对集合中的每个元素应用这个函数。foreach 方法是一种函数式编程风格的迭代方式，通常用于对集合进行操作而不需要显式的循环，该操作只能遍历集合而不能修改集合和集合的元素。（空返回类型）
val arr=Array(1,2,3,4,5,6,7,8,9)
arr.foreach(x=>{if(x%2==0) println("偶数:"+x) else println("奇数:"+x)})这种操作让我们不用再写for循环，简化了代码量，这里将函数作为实参传入
转换（map）
map 是一种高阶函数，用于对集合中的每个元素应用给定的函数，并返回一个新的集合，其中包含了应用函数后的结果。map 操作通常用于转换集合中的元素而不修改原始集合。这里元素的本身会发生变化，但是集合的类型和长度不变。（任意返回类型）
val arr=Array(1,2,3,4,5,6,7,8,9)
val res=arr.map(x=>{if(x%2==0) "偶数" else "奇数"})
res.foreach(x=>println(x))
println(res.getClass.getTypeName)过滤（Filter）
filter 方法是一种集合操作，用于根据给定的条件筛选出集合中满足条件的元素，返回一个新的集合。（布尔返回类型）
val arr=Array(1,2,3,4,5,6,7,8,9)
val even=arr.filter(x=>x%2==0)
val odd=arr.filter(x=>x%2!=0)
even.foreach(x=>println(x))
odd.foreach(x=>println(x))scala 还提供了 filterNot 方法，用于反向过滤，即保留不满足条件的元素。
扁平化（flatten）
flatten 方法用于扁平化嵌套的集合结构，将嵌套的集合展开成一个单层的集合,注意不支持扁平化元组。（任意返回类型）
val arr=Array(Array(1,2,3,4),Array(5,6,7,8))
val res=arr.flatten
for (i <- res ) {
println(i)
}扁平化映射（flatMap）
flatMap 是一种结合 map 和 flatten 的高阶函数，它常用于对嵌套集合进行处理。flatMap 对集合中的每个元素应用一个返回集合的函数，然后将结果扁平化为单个集合，先执行映射map再执行扁平化flatten。（任意返回类型）
val arr=Array("1 2 3 4","5 6 7 8 9")
val res=arr.flatMap(x=>x.split(" "))
res.foreach(x=>println(x))排序（sorted/sortWith/sortBy）
将集合中的元素进行排序，并返回一个新的集合
- sorted 方法默认按照元素的自然顺序进行升序排序。如果要进行降序排序，可以使用 reverse 方法。
- sortWith 方法允许你提供一个自定义的比较函数，根据该函数的返回值进行排序。
- sortBy 方法允许你指定一个用于排序的属性，并且可以使用比较器对象进行升序或降序排序。
var arr=Array(("scala",120),("java",100),("c#",140))
arr.foreach(x=>println(x))
println("================")
arr=arr.sorted
arr.foreach(x => println(x))
println("================")
arr=arr.sortWith((x,y)=>x._2<y._2)
arr.foreach(x => println(x))
println("================")
arr=arr.sortBy(x=>x._2* -1)
arr.foreach(x => println(x))
println("================")并行集合
并行集合是 Scala 中一种利用多核处理器并行计算能力的集合类型。它们提供了一种在并行环境中执行集合操作的方式，允许同时处理多个元素，从而提高计算性能。Scala 标准库中提供了一系列并行集合，主要包括 ParSeq、ParSet、ParMap 等。
归约（reduce/reduceLeft/recuecRight）
- reduce 方法是对集合进行归约的通用方法，它将集合中的元素两两结合，使用指定的二元操作符进行归约，默认从左到右。
- reduceLeft 方法也是对集合进行归约的方法，它从左到右将集合中的元素两两结合，使用指定的二元操作符进行归约。
- reduceRight 方法与 reduceLeft 类似，但是它从右到左将集合中的元素两两结合，使用指定的二元操作符进行归约。
注意点返回值的类型和原元素的类型必须一致
var arr=Array(1,2,3,4,5,6,7,8,9)
val res1=arr.reduce((x,y)=>{println(x,y);x*2+y})
println(res1)
val res2=arr.reduceRight((x,y)=>{println(x,y);x*2+y})
println(res2)折叠（fold/foldLeft / foldRight）
- fold 方法允许指定一个初始值（累加器），并提供一个二元操作符来对集合中的元素进行折叠。它从左到右折叠集合。
- foldLeft 方法也允许指定初始值和二元操作符，它从左到右折叠集合。
- foldRight 方法允许指定初始值和二元操作符，但它从右到左折叠集合。
var arr=Array(1,2,3,4,5,6,7,8,9)
val res1=arr.fold(0)((x,y)=>{println(x,y);x*2+y})
println(res1)
val res2=arr.foldRight(0)((x,y)=>{println(x,y);x*2+y})
println(res2)fold和reduce的差别就在于进行操作时，fold提供的了一个初始器，而reduce用第一个元素作为初始器，上面的初始器为0
聚合（aggregate）
aggregate 是用于对集合进行折叠（或称为聚合）的方法，它相比于 fold 和 reduce 提供更大的灵活性。aggregate 允许你指定初始值、并行度，以及用于局部和全局聚合的两个不同的操作符。
var arr=Array(1,2,3,4,5,6,7,8,9)
val res=arr.par.aggregate(0)((x,y)=>{println("单个线程聚合:",x,y);x+y},(x,y)=>{println("全局聚合:",x,y);x*y})
println(res)分组（groupBy/grouped）
groupBy 接受一个函数，该函数用于根据元素的某个属性进行分组，并返回一个 Map，其中键是分组的标志，值是分组中的元素列表。
grouped 方法用于将集合按指定大小分成固定大小的块。这个方法返回一个迭代器，每个元素都是一个固定大小的子集。
var arr=Array(("scala",14),("python",50),("java",60),("c++",100),("c#",40),("c",50))
val res=arr.groupBy(x=>x._1.charAt(0))
res.foreach(x=>{println(x._1);x._2.foreach(x=>println(x))})
arr.grouped(2).foreach(x=>{x.foreach(x=>print(x));println("\n=============")})重映射（mapValues）
mapValues 是用于对 Map 中的值进行映射操作的方法。mapValues 接受一个函数作为参数，该函数对每个键值对的值进行映射，返回一个新的 Map，其中键保持不变，而值被映射后的结果替代。
var arr=Array(("scala",14),("python",50),("java",60),("c++",100),("c#",40),("c",50))
val res=arr.groupBy(x=>x._1.charAt(0))
res.mapValues(x=>x.sortBy(x=>x._2)).foreach(x=>{x._2.foreach(x=>print(x));print("\n")}) //将每个map里的array按数字大小排序集合的差，并，交: diff，union， intersect
scala实现单词计数操作
object Main {
def main(args: Array[String]): Unit = {
wordcount("In the ethereal glow of the moonlit night, a symphony of crickets serenaded the tranquil meadow, while the silvery beams danced upon the rippling surface of the secluded pond, creating an enchanting spectacle beneath the vast canvas of the star-studded sky.")
}
private def wordcount(wordLine:String):Unit={
val words=wordLine.replaceAll("[^a-zA-Z0-9\\s]", "").split(" ").toList
val res=words.groupBy(x=>x).mapValues(x=>x.length)
res.foreach(x=>println(x._1,x._2))
}
}