scala算子

 scala算子分为转换算子（transform）和行动算子(action)

val arr:Array[T] = Array(3,11,5,9,2)
// 1 数组的元素数量
int size = arr.size 👍

// 2 拷贝 
// 将数组元素的值拷贝一份到参数 buffer 中
arr.copyToBuffer(dest:Buffer[T])
    //val buffer = new ArrayBuffer[Int](arr.size)
    //arr.copyToBuffer(buffer)
    // 将数组元素的值(从指定start(默认为0)位置开始的len(默认目标数组剩余的数量和源数组中元素的数量的
		//最小值)个元素)拷贝一份到参数数组 dest 中
arr.copyToArray(dest:Array[T][,start:Int[,len:Int]])
    //val arrCp:Array[Int] = new Array(3)
    //arr.copyToArray(arrCp)
    //arr.copyToArray(arrCp,2)
    //arr.copyToArray(arrCp,2,10)
    //arrCp.foreach(println)

// 3 遍历集合中的所有元素
arr.foreach(f:T=>U) 👍
	// arr.foreach(println)

// 4 过滤掉(筛选出)需要的元素
// 过滤出满足条件的元素
val newArr:Array[T] = arr.filter(f:T=>Boolean) 👍👍👍
	//arr.filter(_>=10).foreach(println)
// 只收集满足条件的元素
val newArr:Array[O] = arr.collect[T,O](pf:PartialFunction[T,O])
	//arr.collect({case a if(a>=5) => a}).foreach(println)
// 收集第一个满足条件的元素
val ele:Option[O] = arr.collectFirst[T,O](pf:PartialFunction[T,O])
// 查找第一个满足条件的元素
val opt:Option[T] = arr.find(f:T=>Boolean)
//val opt:Option[Int] = arr.find(_ > 4)

// 5 修改指定下标位置元素
arr.update(index:Int,ele:T)
	//arr.update(3,15)
val newArr:Array[T] = arr.updated(index:Int,t:T)

// 6 找位置
// 正向：左向右
// 返回参数元素在集合中的下标，不存在返回-1
val index:Int = arr.indexOf(t:T)
// 从参数2指定下标开始，返回参数1元素在集合中的下标，不存在返回-1
val index:Int = arr.indexOf(t:T,from:Int)
// 返回参数子序列在集合中的下标(完整包含)，不存在返回-1
val index:Int = arr.indexOfSlice(sub:GenSeq[T])
// 从参数2指定下标开始，返回参数1子序列在集合中的下标(完整包含)，不存在返回-1
val index:Int = arr.indexOfSlice(sub:GenSeq[T],from:Int)
// 返回集合中满足参数函数条件的第一个元素的下标，不存在返回-1
val index:Int = arr.indexWhere(f:T=>Boolean)
// 从参数2指定下标开始，返回集合中第一个满足参数1函数条件元素的下标(完整包含)，不存在返回-1
val index:Int = arr.indexWhere(f:T=>Boolean,from:Int)
// 逆向：右向左
// 返回参数元素在集合中的下标，不存在返回-1
val index:Int = arr.lastIndexOf(t:T)
// 从参数2指定下标开始，返回参数1元素在集合中的下标，不存在返回-1
val index:Int = arr.lastIndexOf(t:T,from:Int)
// 返回参数子序列在集合中的下标(完整包含)，不存在返回-1
val index:Int = arr.lastIndexOfSlice(sub:GenSeq[T])
// 从参数2指定下标开始，返回参数1子序列在集合中的下标(完整包含)，不存在返回-1
val index:Int = arr.lastIndexOfSlice(sub:GenSeq[T],from:Int)
// 返回集合中满足参数函数条件的第一个元素的下标，不存在返回-1
val index:Int = arr.lastIndexWhere(f:T=>Boolean)
// 从参数2指定下标开始，返回集合中第一个满足参数1函数条件元素的下标(完整包含)，不存在返回-1
val index:Int = arr.lastIndexWhere(f:T=>Boolean,from:Int)

// 7 提取
// 指定下标的元素
val ele = arr.apply(index:Int)
val ele = arr(index:Int) 👍
val ele = arr.applyOrElse(index:Int,default:Int=>A) 👍
    //val v:Int = arr(3)
    //val ele = arr.applyOrElse[Int,Int](10,_ => -1)
val opt:Option[T] = arr.headOption
val opt:Option[T] = arr.lastOption
// 左侧提取 size 个元素
val arr:Array[T] = arr.take(size:Int)
// 右侧提取 size 个元素
val arr:Array[T] = arr.takeRight(size:Int)
// 左侧提取满足参数条件的元素，若左1就不满足返回空数组
val arr:Array[T] = arr.takeWhile(f:T=>Boolean)

// 8 取两个集合的并集
// ++ 谁在前，最终类型就是谁
val union:Array[T] = arr ++ that:GenTraversableOnce
val union:Array[T] = arr.++ that:GenSeq[T]
val union:Array[T] = arr.union(that:genSeq[T])
// ++: 谁在后，最终类型就是谁
val union:That = arr ++ that:GenTraversableOnce
// 提取 arr 相对于参数集合 sub 的差集
val diffArr = arr.diff(sub:GenSeq[T])
// 提取 arr 和参数集合 sub 的交集
val diffArr = arr.intersect(sub:GenSeq[T])

// 9 追加元素(+号在哪个位置就在哪个位置加)
// 头部追加
val newArr = ele +: arr
// 尾部追加
val newArr = arr :+ ele

// 10 删除元素
// 左删除
val newArr: Array[Int] = arr.drop(num:Int)
// 右删除
val newArr: Array[Int] = arr.dropRight(num:Int)
// 从左侧第一个满足条件开始删除，到第一个不满足条件元素结束，若左一不满足则不做任何删除
val newArr: Array[Int] = arr.dropWhile(f:T=>Boolean)

// 11 转换算子
// 逐一处理数组元素
val newArr:Array[O] = arr.map[T,O](f:T=>O)
val newArr:Array[O] = arr.reverseMap[T,O](f:T=>O)
val map:Map[A,B] = arr.mapValues(f:Array[T]=>B)
val arr2d:Array[Array[T]] = Array(Array(...),...)
// 降维
val newArr:Array[T] = arr2d.flatten
// map + flatten
val newArr:Array[O] = arr2d.flatMap[T,O](f:Array[T]=>Array[O])
// len>arr.size : 超出原数组长度的位置用 padEle 填充
val newArr:Array[T] = arr.padTo(len:Int,padEle:T)
// 将 arr 中从 from 下标位置开始的连续 replacedNum 个元素替换为 seq
// 若 replacedNum 为0，则直接转化为插入操作
// 若 Seq 为空，则直接转化为删除操作
val newArr:Array[T] = arr.patch(from:Int,seq:GenSeq[T],replacedNum:Int)
// 转置
val newArr:Array[T] = arr.reverse
// 将集合转化为元素和下标组成二元组的集合
val ixArr: Array[(T, Int)] = arr.zipWithIndex
// 两个集合按下标join
val arr2:Array[B] = Array(...)
// 交集
//相同下标元素组成的二元组交集集合
val newArr:Array[(T,B)] = arr.zip(arr2)
// 全集
val newArr:Array[(T,B)] = arr.zipAll(arr2,t:T,b:B)
// 将元组集合拆解为2|3个集合构成的2元组
val tp2:(Array[A],Array[B]) = tp2Arr.unzip[A,B]
val tp3:(Array[A],Array[B],Array[C]) = tp2Arr.unzip3[A,B]
    //val tp2Arr = Array((1,"henry"),(2,"ariel"),(3,"john"))
    //val unzip: (Array[Int], Array[String]) = tp2Arr.unzip
    //unzip._1.foreach(println)
    //unzip._2.foreach(println)
// 将数组和某常量构成2元组
val tuple: (Array[T], B) = arr -> b:B
// 将集合元素值以指定开始符号，分隔符，结束符号拼接成字符串
val str1: String = arr.mkString
val str2: String = arr.mkString(",")
val str3: String = arr.mkString("[",",","]")
// 按参数指定数量元素的所有排列组合(和顺序无关)
val it: Iterator[Array[T]] = arr.combinations(num:Int)
// 返回集合中所有元素按全量排列组合的所有情况(和顺序有关)
val it: Iterator[Array[T]] = arr.permutations
// 将集合变成并行数组
val parArr:ParArray[T] = arr.par
// 去重
val distinct: Array[Int] = arr.distinct
// 返回去除【头】元素以外的其他所有元素
val arr:Array[T] = arr.tail
// 返回对于arr递归进行tail处理的所有情况的集合
val it:Iterator[Array[T]] = arr.tails
// 返回去除【尾】元素以外的其他所有元素
val arr:Array[T] = arr.init
// 返回对于arr递归进行init处理的所有情况的集合
val it:Iterator[Array[T]] = arr.inits
// 提取集合下标的区间对象
val rng:Range = arr.indices
// 转数组(非数组集合用)
val array: Array[Int] = arr.toArray
// 去重+元素验证
val set: Set[Int] = arr.toSet
// 验证，关联
val map: Map[Int, (String, Int)] = arr2.toMap
// 动态增删
val buffer: mutable.Buffer[Int] = arr.toBuffer
// 返回所有元素逆序后的新数组
val reverse: Array[Int] = arr.reverse
// 提取集合的逆向迭代器(逻辑实现)
val iterator: Iterator[Int] = arr.reverseIterator

// 12 分组
// 按指定参数数量分组
val it: Iterator[Array[Int]] = arr.grouped(size:Int)
// 滑动：可以指定参数1的窗口大小，参数2的步幅
val it2: Iterator[Array[Int]] = arr.sliding(size:Int, step:Int)
// 截取：from inclusive, to exclusive
val sub: Array[Int] = arr.slice(from:Int, to:Int)
// 分割：按指定位置拆分，指定位置元素在右侧
val tp21: (Array[Int], Array[Int]) = arr.splitAt(splitIndex:Int)
// 分割：将从左1开始连续满足条件的元素分为一组，其他分为另一组
val tp22: (Array[Int], Array[Int]) = arr.span(f:T=>Boolean)
// 返回两个集合的二元组，其一为满足条件的元素，其二为不满足条件的元组
val tp23: (Array[Int], Array[Int]) = arr.partition(f:T=>Boolean)
// 分组：
//简单类型
val map:Map[T,Array[T]] = arr.groupBy(t=>t)
//复杂类型：元组，样例类
val map:Map[X,Array[T]] = arr.groupBy(_._n)
val map:Map[X,Array[T]] = arr.groupBy(_.attribute)

// 13 聚合计算
//聚合计算，配合par转换为并行数组后可以并行计算提升计算效率
val rst:S = arr.par.aggregate[S](s:S)(seqop:(S,T)=>S, combop:(S,S)=>S)
//左右折叠计算
val rst:B = arr.foldLeft[T,B](b:B)(f:(B,B)=>B)
val rst:B = arr.foldRight[T,B](b:B)(f:(B,B)=>B)
val rst:B = arr.reduceLeft[B](f:(B,T)=>B)
val rst:B = arr.reduceRight[B](f:(T,B)=>B)
val rst:Option[B] = arr.reduceLeftOption[B](f:(B,T)=>B)
val rst:Option[B] = arr.reduceRightOption[B](f:(T,B)=>B)
// 和 fold 的差别是：记录计算所有过程结果
val newArr: Array[Int] = arr.scanLeft[T,B](b:B)(f:(B,B)=>B)
val newArr: Array[Int] = arr.scanRight[T,B](b:B)(f:(B,B)=>B)
//累积
val product: Int = arr.product
//累加
val sum: Int = arr.sum
//计数(满足参数条件)
val num: Int = arr.count(f:T=>Boolean)
//返回基本类型集合的最大值
val max:T = arr.max
//返回基本类型集合的最小值
val min:T = arr.min
//根据参数规则返回复杂类型(元组，样例类)的最大值对象
val maxBy:T = arr2.maxBy(a=>a.*)
//根据参数规则返回复杂类型(元组，样例类)的最小值对象
val minBy:T = arr2.minBy(a=>a.*)

// 14 验证
// 集合中是否包含某元素
val bool = arr.contains(t:T)
// 集合中是否完整包含子集合
val bool = arr.containsSlice(sub:GenSeq[T])
// 长度相同的两个集合中的同下标位置的元素是否都满足参数2函数关系
val bool = arr.corresponds(sub:GenSeq[T])(f:T=>Boolean)
// 集合是否以参数子集合开始
val bool1 = arr.startsWith(sub:GenSub[T])
// 集合是否从参数2开始以参数子集合开始
val bool2 = arr.startsWith(sub:GenSub[T],offSet:Int)
// 集合是否以参数子集合结尾
val bool3 = arr.endsWith(sub:GenSub[T])
// 集合中是否至少有一个元素满足参数函数条件
val bool = arr.exists(f:T=>Boolean)
// 集合中是否所有元素满足参数函数条件
val bool = arr.forall(f:T=>Boolean)
// 集合是否为空
val empty:Boolean = arr.isEmpty
// 集合是否非空
val nonEmpty:Boolean = arr.nonEmpty
// 两个集合是否有相同的元素(长度，顺序，同位置的元素)
val same:Boolean = arr.sameElements(it:GenIterable[T])
// 集合从指定参数2位置开始【连续】满足参数1函数条件的元素的数量
val num:Int = arr.segmentLength(f:T=>Boolean,from:Int)

// 15 排序
// 升序
val sorted: Array[Int] = arr.sorted
// _[.?] < _[.?] 升序，_[.?] > _[.?] 降序
val sorted: Array[Int] = arr.sortWith(f:(T,T)=>Boolean)
// _[.?] => _[.?] 升序，_[.?] => -_[.?] 降序
val sorted: Array[Int] = arr.sortBy(f:T=>T)

// 返回函数
// 返回以下标为参数提取集合元素的函数，考虑到索引可能越界，返回类型为Option[T]
val lift: Int => Option[T] = arr.lift