scala数组方法

// 元组    val = (v1,v2,...,v22)    最多22个

// 创建数组
val buffer:ArrayBuffer[T] = ArrayBuffer.empty | ArrayBuffer(...)
val buffer:ArrayBuffer[(Int,Int)] = ArrayBuffer.empty

val array:Array[T] = Array(...)
val array:Array[(Int,Int)] = Array(...)
val array:Array[T] = new Array(length:Int)

// 基本操作
val length = buffer.length
val bool = buffer.isEmpty
val bool = buffer.nonEmpty
val bool = buffer.forall(f:T=>Boolean)                // all
val bool: Boolean = buffer.exists(f:T=>Boolean)        // any
val bool = buffer.contains(t:T)
val bool = buffer.containsSlice(seq:GenSeq[T]) // 是否包含完整的子序列(数量，顺序，内容)
val bool = buffer.startsWith(seq:GenSeq[T][,offset:Int])
val bool = buffer.endsWith(seq:GenSeq[T])
val bool: Boolean = buffer.corresponds(se1:GenSeq[B])(f:(T,B)=>Boolean) // 相关性
val bool: Boolean = buffer.sameElements(se1:GenSeq[B]) // 所有元素同位置同值
val reverse: ArrayBuffer[T] = buffer.reverse // 返回逆向

// 定位
val index = buffer.indexOf(e:T[,from:Int])
val index = buffer.indexOfSlice(seq:GenSeq[T][,from:Int])
val index = buffer.indexWhere(f:T=>Boolean)
val index = buffer.lastIndexOf(e:T[,from:Int])
val index = buffer.lastIndexOfSlice(seq:GenSeq[T][,from:Int])
val index = buffer.lastIndexWhere(f:T=>Boolean)

// 数据移植
val items = buffer.clone()
buffer.copyToBuffer(buf:mutable.Buffer[T])
buffer.copyToArray(array:Array[T][,start:Int[,len:Int]])

// 添加
// buffer.append(e:T*)                        +=
buffer.append((1,111))
// buffer.prepend(e:T*)                        +=:
buffer.prepend((2,112))        
// buffer.appendAll(es:TraversableOnce)        ++=
buffer.appendAll(Array((3,113)))
// buffer.prependAll(es:TraversableOnce)    ++=:
buffer.prependAll(Array((4,114)))
buffer.insert(index:Int,es:T*)
buffer.insertAll(index:Int,seq:Traversable[T])
// 最终类型由左侧表达式的类型决定
val combine:ArrayBuffer[T] = buffer ++ seq:GenTraversableOnce[T]
val newBuffer: ArrayBuffer[T] = buffer :+ t:T
val newBuffer: ArrayBuffer[T] = t:T +: buffer

// 删除
val left: ArrayBuffer[T] = buffer - (T)
val left: ArrayBuffer[T] = buffer -- (seq:TraversableOnce[T])
buffer -= (T)
buffer --= (seq:TraversableOnce[T])
T t = buffer.remove(index:Int)
buffer.remove(index:Int, count:Int)
buffer.clear()
val left1: ArrayBuffer[T] = buffer.drop(size:Int)                // 左删除
val left2: ArrayBuffer[T] = buffer.dropRight(size:Int)            // 右删除
// 元素已升序排序时推荐 : 从左1开始，删除连续满足条件的元素，若左1就不满足则不删除
val left3: ArrayBuffer[T] = buffer.dropWhile(f:T=>Boolean)        // 左删
buffer.trimEnd(size:Int)                                // 右删除size个元素
buffer.trimStart(size:Int)                                // 左删除size个元素
buffer.reduceToSize(size:Int)                            // 削减容量(左保留)
val distinct: ArrayBuffer[(Int, Int)] = buffer.distinct    // 去重

// 修改
buffer.update(index:Int,t:T)    // 直接修改
val newBuffer:ArrayBuffer[T] = buffer.updated(index:Int,t:T)    // 返回新Buffer
// replaced=0:插入, replaced>0:替换, seq为空replaced>0:删除
val after: ArrayBuffer[T] = buffer.patch(from:Int, seq:GenSeq[T], replaced:Int)

// 提取
val item = buffer.apply(index:Int)
val item = buffer.applyOrElse(index:Int,f:Int->T)
val opt: Option[(Int, Int)] = buffer.find(f:T=>Boolean)
val remain1: ArrayBuffer[T] = buffer.filter(f:T=>Boolean)        // 保留满足条件
val remain2: ArrayBuffer[T] = buffer.filterNot(f:T=>Boolean)    // 保留不满足条件
val items: ArrayBuffer[O] = buffer.collect(pf:PartialFunction[I,O])
val items: ArrayBuffer[O] = buffer.collectFirst(pf:PartialFunction[I,O])
/*
    【偏】函数通常用模式匹配，却【不需要模式匹配的完整】
    【collect 案例】
    val pf:PartialFunction[(Int,Int),(Int,Int)] = {
        case (4,_) => (4,1)
        case (0,_) => (0,1)
    }
    val tuples: ArrayBuffer[(Int, Int)] = buffer.collect(pf)
    val opt: Option[(Int, Int)] = buffer.collectFirst(pf)
*/
val head: T = buffer.head                                // 第一个元素
val opt: Option[T] = buffer.headOption                    // 第一个元素
val tail: ArrayBuffer[T] = buffer.tail                    // 除第一个元素以外的其他元素
// 剩余元素(阶梯) 4(1,2,3,4),3(2,3,4),2(3,4),1(4),0()
val tails: Iterator[ArrayBuffer[T]] = buffer.tails

val head: T = buffer.last                                // 最后一个元素
val opt: Option[T] = buffer.lastOption                    // 最后一个元素
val tail: ArrayBuffer[T] = buffer.init                    // 除最后一个元素以外的其他元素
// 剩余元素(阶梯) 4(1,2,3,4),3(1,2,3),2(1,2),1(1),0()
val tails: Iterator[ArrayBuffer[T]] = buffer.inits

val indices: Range = buffer.indices        // 提取下标区间
val size:Int = buffer.prefixLength(f:T=>Boolean) // 左1起连续满足条件元素数量
// 左1起连续满足条件元素数量，从 from 下标开始
val size:Int = buffer.segmentLength(f:T=>Boolean, from:Int)

val tuples1: ArrayBuffer[(Int, Int)] = buffer.take(n:Int)
val tuples2: ArrayBuffer[(Int, Int)] = buffer.takeRight(n:Int)
// 左1起连续满足条件元素数量
val tuples3: ArrayBuffer[(Int, Int)] = buffer.takeWhile(f:T=>Boolean)

//【偏函数与模式匹配】
// 偏函数
val pf:PartialFunction[I,O] = {
    case ...
}

// 遍历(迭代)
buffer.foreach(func:T=>U)
val it: Iterator[T] = buffer.iterator
val it: Iterator[T] = buffer.reverseIterator

// 排序
val sorted = buffer.sorted(order:Ordering[T]) // 元组默认按 _1 升序排序，否则需要提供 order
implicit val orderingInt:Ordering[Int] = Ordering.Int.reverse // 缺省默认升序
implicit val orderingTp2:Ordering[(Int,Int)] = Ordering.by(_._2)
val sorted = buffer.sorted
val sorted = buffer.sortBy(f:T=>B)(implicit order:Ordering[B])
val sorted = array.sortBy(_._2) // 隐式参数默认传入 Odering.Int
val sorted = buffer.sortWith(f:(T,T)=>Boolean)
// a._2>b._2前者大为降序，a._2<b._2前者小为降序
val sorted = buffer.sortWith((a,b)=>a._2>b._2)

// 结果类型：前(左)置确定
// 交集
val intersect:ArrayBuffer[T] = buffer.intersect(seq:GenSeq[T])
// 并集
val union:ArrayBuffer[T] = buffer.union(seq:GenSeq[T])
// 差集
val intersect:ArrayBuffer[T] = buffer.diff(seq:GenSeq[T])

// 一个维度的转变
val buffer:ArrayBuffer[O] = buffer.map(func:T=>O)        // 正向差异类型转变
val buffer:ArrayBuffer[O] = buffer.transform(func:T=>T)    // 正向同类型转变
val ints: ArrayBuffer[O] = buffer.reverseMap(func:T=>O)    // 逆向转变
// 合并：最短原则
val buffer:ArrayBuffer[(T,B)] = buffer.zip(it:GenIterable[B]) // 
// 合并：最长+默认
val buffer:ArrayBuffer[(T,B)] = buffer.zipAll(it:GenIterable[B],thisE:T,thatE:B)
// 合并：+索引
val buffer:ArrayBuffer[(T,Int)] = buffer.zipWithIndex
// 拆解：二元组
val buffer:(ArrayBuffer[A],ArrayBuffer[B]) = buffer.unzip(f:T=>(A,B))
// 拆解：三元组
val buffer:(ArrayBuffer[A],ArrayBuffer[B],ArrayBuffer[C]) = buffer.unzip3(f:T=>(A,B,C))
// 填充
val tuples: ArrayBuffer[T] = buffer.padTo(size:Int, elem:T)
// 连接字符串
val str0: String = buffer.mkString
val str1: String = buffer.mkString(sep:String)
val str2: String = buffer.mkString(start:String,sep:String,end:String)
// 二维的转变算子
val buffer:ArrayBuffer[O] = buffer2D.flatMap(func:T=>O)
val buffer:ArrayBuffer[O] = buffer2D.flatten
// 二维转置
val transpose: ArrayBuffer[ArrayBuffer[Int]] = buffer2D.transpose
// 类型
val buffer: mutable.Buffer[T] = buffer.toBuffer // 为了增删
val array: Array[T] = buffer.toArray            // 非数组(下标，排序)
val par: ParArray[T] = buffer.toParArray        // 分布式计算
val map: Map[K, V] = buffer_tp2.toMap             // 键值映射
val set: Set[T] = buffer.toSet                    // 去重

// 分组
val bufferSlice: ArrayBuffer[T] = buffer.slice(start:Int, end:Int) // 切片
val itAB: Iterator[ArrayBuffer[T]] = buffer.sliding(size:Int, step:Int) // 滑窗
// grouped(size) <=> sliding(size,size)
val itAB: Iterator[ArrayBuffer[T]] = buffer.grouped(size:Int)    // 定长分组
val map: Map[K, ArrayBuffer[T]] = buffer.groupBy(func:T=>K)        // 按键分组
val tp2: (ArrayBuffer[T], ArrayBuffer[T]) = buffer.partition(f:T=>Boolean) // 2分区
val splits: (ArrayBuffer[T], ArrayBuffer[T]) = buffer.splitAt(n:Int) // 2分区
// 全量排列组合(只考虑顺序)
val permutations: Iterator[ArrayBuffer[(Int, Int)]] = buffer.permutations
// 定长排列组合(与顺序无关)
val it: Iterator[ArrayBuffer[(Int, Int)]] = buffer.combinations(size:Int)

// 计算
// 数组元素为数值类型可以直接计算
val sum = buffer.sum
val max = buffer.max
val min = buffer.min
val min = buffer.product    // 阶乘
// 非数值元素类型
val sum = buffer.map(f:T=>Number).sum
val max = buffer.maxBy(f:T=>O:Comparable)
val min = buffer.minBy(f:T=>O:Comparable)
val cnt = buffer.count(f:T=>Boolean)
// 计算优化：并行序列，并行计算
val par: ParArray[T] = buffer.par
// 高阶计算：聚合
val rst:O = buffer.aggregate(o:O)(map:(O,T)=>O,red:(O,O)=>O)
val rst:O = par.aggregate(o:O)(map:(O,T)=>O,red:(O,O)=>O)        // 并行 Map & Red
val rst:O = buffer.fold[Left|Right](init:O)(func:(O,O)=>O)        // 双向折叠
val rst:ArrayBuffer[O] = buffer.scan[Left|Right](init:O)(f:(O,O)=>O) // 过程结果
val rst:O = buffer.reduce[Left|Right](f:(O,O)=>O)