SCALA中集合常用函数大全(二)

Scala集合操作

最新推荐文章于 2023-08-05 09:48:39 发布

原创最新推荐文章于 2023-08-05 09:48:39 发布 · 1k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#scala

scala 专栏收录该内容

6 篇文章

订阅专栏

本文介绍了Scala中集合的各种操作方法，包括reduce、distinct等函数的应用，集合间的交并差运算，以及zip、zipWithIndex等组合与索引标记方法。此外还探讨了slice、sliding等用于切片与滑动窗口处理的函数。

函数目录:

1.reduce函数

2.集合的交集并集和差集

3.scala2.13.X版本中比2.12.2多出来的两个函数

4. distinct 函数和distinctBy 函数

5. zip 函数

6.swap 函数

7.zipWithIndex函数

8 fold和foldRight 函数 mkString函数(这个函数是常用的)

9. SCAN函数

10 slice 函数

11 silding函数

12 take takeRight takeWhile

13 aggregate

14 集合之间的转换函数

1.reduce函数

用法:对集合中的元素进行累加的操作,如果是字符串则是对字符串的拼接

    //reduce函数
    //先定义一个集合
    val ls = List(1, 5, 9, 8, 6, 3)

    val i = ls.reduce(_ + _)//这个方法是默认从左边开始累加   (((1+5)+9)+8)+6
    val i1 = ls.reduce(_ - _)//这个方法是默认从左边开始累减   (((1-5)-9)-8)-6
    val i2 = ls.reduceRight(_ + _)//这个方法是从右边开始累加 1+(5+(9+(8(6+3))))
    val i3 = ls.reduceRight(_ - _)  //这个方法是从右边开始累加 1+(5+(9+(8(6+3))))

2.集合的交集并集和差集

集合的交集( intersect() ) :求连个集合相交,生产一个有共同元素的集合

集合的并集( union() ):将两个集合中的元素放在同一个集合中,但是不会去重,如果需要去重,可以将list集合转为set集合或者是调用distinct方法,进行去重

集合的差集:( diff() ) 在集合一中有的在集合二中没有
    //先定义两个集合
    val ls = List(1, 3, 5, 7, 9)
    val ls2 = List(4, 2, 5, 7, 9)
    //求两个集合的交集
    println(ls.intersect(ls2))  //结果为:List(5, 7, 9)
    //求两个集合并集:就是将两个集合中的所有元素都放在同一个集合中,但是不会去重
    println(ls.union(ls2))//结果为:List(1, 3, 5, 7, 9, 4, 2, 5, 7, 9)
    //就连个集合的差集:在集合1中出现了在集合2中没有出现的
    println(ls.diff(ls2))//结果为:List(1, 3)

3.scala2.13.X版本中比2.12.2多出来的两个函数

distinctBy 这个函数可以根据一定的维度进行去重,比如说是对一个集合中放了一个元组,可以按照元组中的某个元素进行去重,也可以对map集合中的某个值进行去重

distinct 用来对单一维度进行去重

concat 这个函数只在2.13 版本中有,作用是将两个集合中的元素,合并成一个集合,但还是不会去重

4. distinct 函数和distinctBy 函数

distinct 作用是对集合进行去重,去重只能按照单一维度进行去重
 //distinct 对集合中的元素进行去重
    val ls = List(1, 5, 9, 8, 7, 5, 6, 3, 1, 2)
    println(ls.distinct)//结果为List(1, 5, 9, 8, 7, 6, 3, 2)
distinctBy 可以按照集合中的某一维度进行去重,比如说对map集合中按照value值进行去重
    //按照map结合中的value值进行去重,先要将map集合转为list集合,然后在进行去重
    val map = Map("zss" -> 20, "lss" -> 22, "ww" -> 22, "ff" -> 9)
    println(map.toList.distinctBy(_._2))//结果为:List((zss,20), (lss,22), (ff,9))

5. zip 函数

zip函数的作用:将两个集合中的元素,角标相同的元素组合为一对元组放在新的集合中,通常是以元素少的集合为基准,进行组合,如下:
    //定义两个集合
    val ls3 = List("sl" ,"wd" ,"em" , "em")
    val arr = Array("fsy","zsf","zhiruo" , "老娜")
    //将两个集合进行拉练操作
    println(ls3.zip(arr))//结果为:List((sl,fsy), (wd,zsf), (em,zhiruo), (em,老娜))

6.swap

swap函数的作用是,将对偶元组中的元素的K和V 进行互换位置

//定义一个集合中放对偶元组
val tuples = List(("zss", 20), ("lss", 15), ("ww", 17), ("ss", 11))
    //遍历集合,将集合中的对偶元组进行位置互换,K=>V  变成 V=>K
    tuples.map(e => {
      val swap = e.swap
      swap
    }).foreach(println)
//结果为:
(20,zss)
(15,lss)
(17,ww)
(11,ss)

7.zipWithIndex函数

用法:遍历集合中的每个元素 , 将每个元素打上对应的索引值 , 组成元组(element , index) 返回新的集合 !
    //定义一个数组
    val arr = Array("fsy","zsf","zhiruo" , "老娜")
    //使用zipWithIndex方法进行
    val index: Array[(String, Int)] = arr.zipWithIndex
    index.toList.foreach(println)
/*
结果为:
   (fsy,0)
   (zsf,1)
   (zhiruo,2)
   (老娜,3)
*/

8 fold和foldRight 函数 mkString函数(这个函数是常用的)

这两个函数的用法和reduce函数的用法比较类似,只是比reduce函数多了一个初始值

fold 函数:

//定义一个数组
    val arr3 = Array("tom" , "cat" , "jim" , "rose")
    // 遍历集合中的每个元素进行拼接  比reduce函数多出一个初始值
    val res = arr3.fold("hello")(_+" "+_)
    println(res)//结果为:hello tom cat jim rose

foldRight函数:是从右开始拼接

    val arr3 = Array("tom" , "cat" , "jim" , "rose")
    val str = arr3.foldRight("hello")(_ + " " + _)
    println(str)//结果为:tom cat jim rose hello

mkString函数:按照给定的字符,将结合中的每一个元素拼接起来

val arr = Array("cat", "com", "jim", "scala", "spark")
    val str: String = arr.mkString(":")
    println(str)//结果展示:cat:com:jim:scala:spark

9. SCAN函数

函数的用法:一个初始值开始，从左向右遍历每个元素，进行积累的op操作,这个函数的作用就是将每一步累加的操作都展示出来

    val arr = Array("cat" , "jim" , "tom")
    // ArraySeq(hello, hello cat, hello cat jim, hello cat jim tom)
    println(arr.scan("hello")(_ + " " + _).toList)//结果为:List(hello, hello cat, hello cat jim, hello cat jim tom)
    val nums = List(1,2,3)
    // List(10,10+1,10+1+2,10+1+2+3) = List(10,11,12,16)
     println(nums.scan(10)(_ + _).toList)//结果为List(10, 11, 13, 16)

10 slice 函数

函数的用法:slice(from: Int, until: Int): List[A] 提取列表中从位置from到位置until(不含该位置)的元素列表, 起始位置角标从0开始,参数一:角标其实位置开始,参数二:角标末尾位置结束,不包含末尾位置
    //这个函数是	slice(参数一,参数二) 参数一:角标的其实位置  参数二:角标的末尾位置不包含 [参数一,参数二 )
    val arr = Array("a", "b", "c" ,"d","e","f")
    val str = arr.slice(0, 2)
    println(str.toList)//结果为:List(a, b)

11 silding函数

sliding 的作用:sliding(size: Int, step: Int): Iterator[List[A]] 将列表按照固定大小size进行分组，步进为step，step默认为1,返回结果为迭代器
Sliding(参数一,参数二)  参数一:窗口大小 , 参数二:步进数,默认为1,可以一写
特点:

1.当步进小于窗口大小时,数据会重复处理

2.当步进大于窗口大小时,会出现数据丢失的现象

3.当步进等于窗口大小时,数据当前仅处理一次
val nums = List(1, 1, 2, 2, 3, 3, 4, 4, 6)
    val ls: Iterator[List[Int]] = nums.sliding(2, 2)
    ls.foreach(println)
//结果展示:
    //List(1, 1)
    //List(2, 2)
    //List(3, 3)
    //List(4, 4)
    //List(6)

12 take takeRight takeWhile

take:从集合中取元素,默认是从左开始取
    val nums = List(1, 1, 2, 2, 3, 3, 4, 4, 6)
    println(nums.take(3)) //结果展示:List(1, 1, 2)
takeRight: 从集合中取元素,从右开始取
      val nums = List(1, 1, 2, 2, 3, 3, 4, 4, 6)
    println(nums.takeRight(3))// 结果展示:List(4, 4, 6)
takeWhile 函数:从集合中取元素,拿集合中的每一个元素进行判断,判断是true放到集合中,如果是false则立刻停止
    val nums = List(1, 1, 2, 2, 3, 3, 4, 4, 6)
    println(nums.takeWhile(_ > 3)) //结果展示:List()
// 因为集合中的第一个元素就不符合判断条件所以就立刻终止的集合中的循环

13 aggregate