scala的常见函数与方法(二)

交集并集差集

val list = List(1,2,3,4,5)
val arr = Array(3,4,5,6,7)

//交集
arr.intersect(list).foreach(println)

//差集 在集合1中出现,集合2中没有出现的元素
list.diff(arr).foreach(println)

//并集
list.union(arr).distinct.foreach(println)

拉链操作

拉链操作就是以数据少的为主,从左到右,形成对偶元组

val list = List(1,2,3,4,5)
var arr = Array("a","b","c","c","d")

/list.zip(arr).foreach(print)  //(1,a)(2,b)(3,c)(4,d)

// zipWithIndex 默认给予一个角标与其组成元组

//arr.zipWithIndex.foreach(print) //(a,0)(b,1)(c,2)(d,3)

// 先调用 zip 形成对偶元组 在调用zipWithIndex
//arr.zip(list).zipWithIndex.foreach(print) //((a,1),0)((b,2),1)((c,3),2)((d,4),
// 元组数据可以转换成map 但要注意 map 的key不能重复,且取出不保证有序
val index: Array[(String, Int)] = arr.zipWithIndex
val map: Map[String, Int] = index.toMap

aggregate聚合

aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值,在2.13+版本中被foldLeft取代.

val ls = List(1,2,3,4,5,10)
//对list集合开启并行化
val par: ParSeq[Int] = ls.par
//默认值只参与局部运算
val i: Int = par.aggregate(0)(_ + _, _ * _)
println(i)

窗口操作 slice / sliding

slice(from: Int, until: Int): List[A] 提取列表中从位置from到位置until(不含该位置)的元素列表

val arr = Array("a", "b", "c" ,"d","e","f")
// 起始角标  结束角标  [1,3) -->  1,2
println(arr.slice(0, 3).toList)

sliding(size: Int, step: Int): Iterator[List[A]] 将列表按照固定大小size进行分组，步进为step，step默认为1,返回结果为迭代器

val arr = Array("a", "b", "c" ,"d","e","f")
val iterator: Iterator[Array[String]] = arr.sliding(3, 3)
iterator.map(_.toList).foreach(println)
    List(a, b, c)
    List(d, e, f)