Scala中Array算子总结

Scala中Array算子总结

提取元素 23 个

arr.foreach(f:t => Unit)  //一个foreach可以解析一层（维）数据
val head: Int = arr.head //获取集合的第一个元素 arr空则报错
val last: Int = arr.last //获取集合的最后一个元素 arr空则报错
val head: Option[T] = arr.headOption //获取集合的第一个元素 arr空则返回None
val last: Option[T] = arr.lastOption //获取集合的最后一个元素 arr空则返回None
val v:T = arr(index) //取下标位置的元素，数组专属
val v:T = arr.apply(index) //取下标位置的元素，都可以用
val v:T = arr.applyOrElse(5, (ix: Int) => ix) //根据参数1提取提取集合元素，下标存在则返回下标对应值，否则将越界下标作为参数传入参数2的函数
val arr:Array[T] = arr.take(size:Int) //从左边取size个元素
val arr:Array[T] = arr.takeRight(size:Int) //从右边取size个元素
val arr:Array[T] = arr.takeWhile(f:T=>Boolen)//从下标0开始取，从第一个满足条件元素开始到第一个不满足条件元素结束  第一个不满足则返回空
val arr:Array[T] = arr.filter(f:T=>Boolen) //提取集合中所有满足条件的元素
val arr:Array[T] = arr.filterNot(f:T=>Boolen) //提取集合中所有不满足条件的元素
val arr: Array[T] = arr.collect(pf) //提取集合中符合偏函数条件的元素，功能类似过滤器，但是性能高于过滤器
	//简化写法
    arr.collect({case x if(x%2==1) =>x}).foreach(println)
val arr: Option[T] = arr.collectFirst({ case x if (x % 2 == 1) => x }) //提取集合中符合参数函数条件的第一个元素 返回的是Option
val arr: Option[T] = arr.find(f:T=>Boolen) //找到集合中符合参数函数条件的第一个元素 find <==> collectFirst
val arr: Array[T] = arr.slice(from:Int,until:Int) //提取从from 至 until 之间的所有元素 前包后不包
val arr: Array[Int] = arr1.init //返回最后一个元素以外的其他元素的集合
val arr: Iterator[Array[Int]] = arr1.inits  //递归返回最后一个元素以外的其他元素的集合，直至集合里没有元素，并封装成迭代器返回。最后一个集合为空集合
val arr: Array[Int] = arr1.tail //返回第一个元素以外的其他元素的集合
val arr: Iterator[Array[Int]] = arr1.tails //递归返回第一个元素以外的其他元素的集合，直至集合里没有元素，并封装成迭代器返回。最后一个集合为空集合

val lift: Int => Option[Int] = arr.lift //返回根据下标提取Option[T]数组元素的函数  因为是Option所以不会有下标越界报错
val pf: PartialFunction[T,B] = arr.orElse(f:PartialFunction[T,B]) //返回根据参数偏函数规则提取数组元素的偏函数

修改操作 12个

Unit返回空值   arr.update(index,value)  //修改下标位置的值
val newArr: Array[T] = arr.updated(index:Int,newV:T) //修改指定下标位置元素值为newV，并返回修改后的整个数组
val newArr: Array[Int] = arr1 ++|union arr2  //两集合相加（并集） 返回值类型为 ++前的集合类型
val newArr: Array[Int] = arr1.intersect(arr2) //前一个集合于第二个集合交集
val newArr: Array[Int] = arr1.diff(arr2)  //前一个集合于第二个集合差集
val newArr: Array[Int] = 1 +: arr1 //头部追加一个元素  ：指向一个集合
val newArr: Array[Int] = arr1 :+ 1  //尾部追加一个元素  ：指向一个集合

val newArr: Array[Int] = arr1 ++: arr2 // 两集合相加（并集） 返回值类型为 ++:后的集合类型
val newArr: Array[Int] = arr1.drop(n:Int) //返回删除左n个元素的副本
val newArr: Array[Int] = arr1.dropRight(n:Int) //返回删除右n个元素的副本
val newArr: Array[Int] = arr1.dropWhile(f:Int=>Boolen) //从左删除第一满足参数函数条件的元素到最后一个把满足条件的元素，如果第一个不满足就什么也不删
val newArr =arr.patch(from:Int,sub:GenSeq,replaceLen:Int) //将原数组中从from开始的repalceLen个元素替换为GenSeq，若sub为空则从from开始删除replaceLen个元素

逐个迭代处理 5个

val tarr:Array[T] = arr.map(f:T=>B) //取出数组中的每个元素，进行f函数的操作
val tarr:Array[T] = arr.transform(f:T=>B) //功能与map相似
val tarr:Array[T] = arr.reverseMap(f:T=>B) 
val tarr:Array[T] = darr.flatten //对二维数组进行降维 一个flatten降一个维度
val tarr:Array[T] = darr.flatMap(f:T=>T)  //flat + map arr2.flatMap(_.map(_ + 2))   <=>  arr2.flatten.map(_ + 2)

分组 5个

val parr:ParArray[T] = arr.par //并行序列
var tuple:(Array[T],Array[T]) = arr.partition(f:T => Boolean) //根据f函数进行分组，返回值为一个元组。
var iter:Iterator[Array[T]] = arr.grouped(size:Int) //指定每组元素的个数  arr.grouped(3)  <==>  arr.sliding(3,3)
 例子： val iterator: Iterator[Array[Int]] = arr3.grouped(3)
        iterator.foreach(arr =>{
          arr.foreach(x=>print({s"${x}\t"}))
          println()
        })
var iter:Iterator[Array[T]] = arr.sliding(size:Int[,step:Int 默认1]) //指定每组有size个元素，每组第一个元素下标与前一组第一个元素的下标的差值为step  ♥♥♥
var map:Map[K,Array(T)] = arr.groupBy(key:K)//根据指定元素分组，返回值为一个键值对，键为指定分组元素，值为包含组内所有对象的数组

聚合 17个

val value:B = arr.reduce(f:(T,T)=>B) //聚合，执行f函数 执行顺序（假设f为相减）为 [arr(0)-arr(1)]-arr(2)...
val value:B = arr.reduceLeft(f:(T,T)=>B) //与reduce一样
val value:B = arr.reduceLeftOption(f:(T,T)=>B) //功能与reduce类似 空集合时返回None 不报错
val value:B = arr.reduceRight(f:(T,T)=>B) //聚合，执行f函数 执行顺序（假设f为相减）为 [arr(4)-arr(5)]-arr(3)...
val value:B = arr.reduceRightOption(f:(T,T)=>B) //功能与reduceRight类似 空集合时返回None 不报错
val value:B = arr.foldleft(initVal:T)(f:(T,T)=>B) //  /:左折叠 initVal为给定的起始值，执行f函数。执行顺序(假设f为相减)为：[initVal-arr(0)]-arr(1)...
val value:B = arr.foldRight(initVal:T)(f:(T,T)=>B) // :\右折叠initVal为给定的起始值，执行f函数。执行顺序(假设f为相减)为：[arr(5)-initVal]-arr(4)... 

val value:Array[B] = arr.scan(initiVal:T)(f:(T,T)=>B) //运算过程与fold相同，但是fold只返回最终结果，而scan将每一个过程结果都包装到一个数组中返回
val value:Array[B] = arr.scanLeft(initiVal:T)(f:(T,T)=>B)//与scan相同
val value:Array[B] = arr.scanRight(initiVal:T)(f:(T,T)=>B)//与scan类似 运算顺序不用
val value:B = arr.par.aggregate(initV:B)(map:(T,T)=>B,reduce:(B,B)=>B)   //并行，速度快
val value:T = arr.sum  //求和
val value:Int = arr.count(f:T => Boolean)  //记录满足f函数的个数
val value:T = arr.min //求最小
val value:T = arr.max //求最大
val value:T = arr.minBy(_.?)  //根据一个元组或一个样例类对象的某个元素比较，取最小值
val value:T = arr.maxBy(_.?)  //根据一个元组或一个样例类对象的某个元素比较，取最大值

验证 10个

val bool: Boolean = arr1.isEmpty // 是否为空
val bool: Boolean = arr1.nonEmpty //是否不为空
val bool: Boolean = arr1.exists((p: Int) => Boolean) //集合中是否存在符合参数函数条件的元素
val bool: Boolean = arr1.contains(x:T) //集合中是否包含参数
val bool: Boolean = arr1.containsSlice(Array(2, 3)) //集合中是否包含完整的子序列 
val bool: Boolean = arr1.forall((p: Int) =>Boolean) //集合中所有元素是否都符合参数函数条件
val bool: Boolean = arr1.corresponds(sub:GenSeq)(p: Int) =>Boolean) //集合中是否所有参数按照索引顺序和参数序列符合参数函数特征
val bool: Boolean = arr1.sameElements(Array(1, 2, 3, 5, 3)) //两个集合中的元素是否相同，且顺序一致
val bool: Boolean = arr1.startsWith(Array(1, 2, 3)) //集合是否已参数子序列开头  
val bool: Boolean = arr1.endsWith(Array(3)) //集合是否已参数子序列结尾

大小 4个

val len:Int = arr.size = arr.length  //数组长度
val len:Int = arr.prefixLength((f: T) =>Boolean) //集合中从左侧开始连续满足参数函数条件的元素数量，若第一个就不满足则为0
val len:Int = arr.segmentLength((f:T) =>Boolean,pos:Int) //从参数2位置开始（包含）连续满足参数函数条件的元素数量
val len:Int = arr.lengthCompare(x:Int) //数组的长度和参数值的差值

转变 26个

val buffer: mutable.Buffer[T] = arr.toBuffer //转化为可变集合Buffer  可进行追加等操作buffer.append(11)
val arr:Array[T] = arr.toArray
val buf:mutable.Buffer[Int] = mutable.Buffer()
val unit: Unit = arr.copyToBuffer(buf) //转化为Buffer 注意传入参数为一个Buffer
val unit: Unit = arr.copyToArray(copy:Array[T])//将源数组arr中的元素拷贝到目标数组copy中
val unit1: Unit = arr.copyToArray(copy:Array[T], 1)//将源数组中的元素标集合的参数2位置开始拷贝，直至目标集合满或原数组结束
val unit1: Unit = arr.copyToArray(copy:Array[T], 1，5)//将源数组中的元素从目标集合的参数2位置开始拷贝参数3个元素，直至目标集合满或原数组结束
val arr:Array[T] = arr.clone  //复制出一个一样的数组（副本）
val arr: Array[T] = arr.array //返回一个数组（自己本身）
val arr: IndexedSeq[T] = arr.deep//获取集合副本
val arr: mutable.WrappedArray[T] = arr.repr //获取集合副本
val arr: mutable.IndexedSeq[T] = arr.seq//获取集合副本
val map:Map[K,V] =arr.toMap  //转为map类型 键值映射 元组
val set: Set[T] = arr1.toSet  //转化为不重复值
val ita: Iterator[T] = arr1.toIterator //获取集合的迭代器对象，只能迭代一次
val ita: Iterable[T] = arr1.toIterable //可重复迭代
val stream: Stream[T] = arr1.toStream //不定数量元素遍历。转化为流，懒加载模式。转化为成第一个元素及其他元素的流形式
val arr: Array[T] = arr.padTo(len:Int,elem:T) //如果源数组的长度小于参数1，以参数2作为默认值填充补全【剩余元素】
val tp2: (Array[T],Array[T]) = arr.span(f:T => Boolean) //将集合从左侧第一个满足的条件的元素到第一个不满足的条件的元素结束作为一个数组,剩余的元素作为另一个数组，将两者包装成元组返回
val tp2: (Array[T],Array[T]) = arr.splitAt(index:Int) //将集合以参数作为临界点（参数下标放于后者）分割成两个数组，并包装成元组返回
val arr2d2: Array[Array[T]] = arr2d1.transpose //二维矩阵转置  
val arr: Array((T,B)) = arr1[T].zip(arr2[B])  //将两个集合每相同下标的两个元素组合成元组，并将其包装成数组返回,如果两个集合的长度不一致，则多余的长度将被忽略。Array(1,2,3).zip(Array(4,5,6)) ==> Array((1,4),(2,5),(3,6))
val arr: Array((T,B)) = arr1[T].zipAll(arr2[B],thisElem:T,thatElem:B) //将两个集合每相同下标的两个元素组合成元组，并将其包装成数组返回.如果arr1的长度大于arr2的长度 则元组_2值由thatElem作为默认值,如果arr1的长度小于arr2的长度 则元组_1值由thisElem作为默认值 Array("chen","chen","chen").zipAll(Array(4,5,6,56,4),"UNKNOWN",16)
val tp2:Tuple(Array[T],Array[T]) = arr[Array[Tuple2]].unzip //将由元组构成的数组中_1和_2单独抽离并分别包装成2个数组，并包装成由两个数组构成的元组返回
val tp3:Tuple(Array[T],Array[T],Array[T]) = arr[Array[Tuple3]].unzip3 //将由元组构成的数组中_1和_2和_3单独抽离并分别包装成3个数组，并包装成由两个数组构成的元组返回
val tp2:Array((T,Int)) = arr.zipWithIndex // 将集合每个元素及对应的下标包装成元组，并将所有元组包装成数组返回

排序 5个

val arr: Array[T] = arr.reverse //倒序副本
val arr； Iterator[T] = arr.reverIterator //倒序迭代器
val arr: Array[T] = arr.sorted  //升序
val arr: Array[T] = arr.sortBy  //x=>x升序 x=>-x降序
val arr: Array[T] = arr.sortWith(f:(T1,T2)=>Boolean) // _<_ 升序  _>_降序

字符串拼接 4个

// 多个集合拼接字符串
val builder = new StringBuilder
val str1: StringBuilder = arr1.addString(builder)  
val str2: StringBuilder = arr1.addString(builder,",")  //指定分隔符，输出结构为：1,2,3,4的形式
val str3: StringBuilder = arr1.addString(builder,"{",",","}")  //指定分隔符和开始及结束符号，输出结构为：{1,2,3,4}的形式
// 单个集合拼接字符串
val string: String = arr1.mkString
val str: String = arr1.mkString(",")
val str1: String = arr1.mkString("{", ",", "}")

根据值取下标 7个

val ix:InT = arr.indexOf(v:T[,start:Int])
val ix:InT = arr.indexOfSlice(arr:GenSeq[,start:Int])
val ix:InT = arr.indexOfWhere(f:T=>Boolean[,start:Int])
val ix:InT = arr.lastIndexOf(v:T[,start:Int])
val ix:InT = arr.lastIndexOfSlice(arr:GenSeq[,start:Int])
val ix:InT = arr.lastIndexOfWhere(f:T=>Boolean[,start:Int])
val ixs:Array[Int] = arr.indices  //返回所有下标集合

oop 4个

//函数组装 函数 f1 f2 f3
val f4 = f1 andThen(f2) andThen f3  // 多个函数组合，先执行f1函数然后f2函数最后f3函数
val f5 = f1 compose f2 compose  f3  // 多个函数组合，先执行f3函数然后f2函数最后f1函数

//类型判定和转换
abstract class Father
case class Son() extends Father
case class Son2() extends Father

val f1:Father = Son()2  //自动类型转换

if(f1.isInstanceof[Son]){
    val s1:Son = f1.asInstanceOf[Son] //强制类型转换
}else{
  println("类型不一致")  
}