scala数组函数
val a = Array(1,2,3,4)
val b = Array(5,6,7,8)
- def ++
- 合并集合,并返回一个新的数组,新数组包含左右两个集合对象内容
val c=a++b
- def ++:
- 合并成一个新的数组,右边操纵数的类型决定着返回结果的类型
val c = a++:c
- def +:
- 在数组前面添加一个元素,并返回新对象
val c = 1+:a
- def :+
- 在数组末尾添加一个元素,并返回新对象
val c = a:+1
- def /:
- 对数组中所有的元素进行相同的操作
val c =(10/:a)(_+_)
- def addString(b:StringBuilder)
- 将数组中的元素逐个添加到b中
val c = new StringBulider()val d = a.adString(b)
- def addString(b:StringBuilder,sep:String):StringBuilder
- 每个元素用sep分割符分开
val c = new StringBulider()val d = a.adString(b,",")
- def addString(b:StringBuilder,start:String,sep:String,end:String):StringBuilder
- 在首位各加一个字符串,并指定sep分隔符
val c = new StringBulider()val d = a.adString(b,"{",",","}")
- def aggregate()()
- 聚合计算,aggregate是柯里化方法,参数是两个方法
val c = a.par.aggregate(5)(_+_,_+_)
- def apply(i:Int)
- 取出索引处的元素
val c = a.apply(0)
- def canEqual(that:Any)
- def charAt(index:Int)
- 获取index索引处的字节
val c = a.charAt(0)
- def clone()
- def collect(pf:PartialFunction[A,B])
- 通过执行一个并行计算,得到一个新的数组
val fun:PartialFunction[Int,Int]={case 1 => 'A' case x = > x}val c = chars.collect(fun)
- def collectFirst(pf:PartialFunction[T,B])
- 在序列中查找第一个符合盘函数定义的元素,并执行偏函数计算
val fun:PartialFunction[Any,Int]={case x:Int => x*100}val c = a.collectFirst(fun)
- def combinations(n:Int)
- 排列组合,这个组合会选出所有包含字符不一样的组合
val c = a.combinations(2)
- def contains(A1>:A)
- def containsSlice(that:GenSeq)
- def copyToArray(x:Array)
- 将一个数组拷贝到另一个里,可以给定起始位置和结束位置
val c:Array[Int] = new Array[4]a.copyToArray(c)
- def copyToBuffer(dest:Buffer)
- 将数组中的内容拷贝到Buffer中
val c:ArrayBuffer[Int] =ArrayBuffer()a.copyToBuffer(c)
- def corresponds(that:GenSeq)
- 判断两个序列长度以及对应位置元素是否符合某个条件
a.corresponds(b)(_<_)
- def count(p:(T)=>Boolean)
- 统计符合条件的元素个数
a.count({x:Int=> x>2})
- def diff(that:Collection.Seq[T])
- 计算当前数组与另一个数组的不同
val c = a.diff(b)
- def distinct
- def drop(n:Int)
- 将当前序列中前n个元素去除后,作为一个新序列返回
val c = a.drop(1)
- def dropRight(n:Int)
- def dropWhile(p:(T)=>Boolean)
- 去除当前数组中符合条件的元素,从第一个元素开始就要满足条件,知道碰到第一个不满足的元素结束
val c = a.dropWhile({x:Int => x<3})
- def endsWith(that:GenSeq)
- def exits(p:(T)=>Boolean)
- 判断当前数组是否包含符合条件的元素
a.exists({x:Int=>x<3})
- def filter(p:(T)=>Boolean)
- 取得当前数组中符合条件的元素,并返回一个新的数组
val c = a.filter({x:Int=>x<3})
- def filterNot(p:(T)=>Boolean)
- def find(p:(T)=>Boolean)
- 查找第一个符合条件的元素
val c = a.find({x:Int=>x<3})
- def flatMap(f:(A)=>GenTraversableOnce)
- 对当前序列的每个元素进行操作,结果放入新序列返回
val c=a.flatMap(x=>1 to 5)
- def flatten
- 将二维数组的所有元素联合在一起,形成一个新的数组返回
val c = Array(1,(1,2))val d = c.flatten
- def fold(z:A1)(op:A1,A1)=>A1)
- 对序列中的每个元素进行二元运算
val c = a.fold(3)(_+_)
- def foldLeft(z:B)(op:(B,T)=>B)
- def foldRight(z:B)(op(B,T)=>B)
- def forall(P:(T)=>Boolean)
- 检测序列中的元素是否都满足条件p
val c = a.forall({x:Int=>x>0})
- def foreach(f:(A)=>Boolean)
- 检测序列中的元素是否都满足条件p
val c= a.foreach({x:Int=>x<2})
- def foreach(f:(A)Unit)
- def groupBy(f:(T)=>K)
- 按条件分组
val c = a.groupBy(x=>match{case x if (x<3) => "small" case _ => "big"})
- def grouped(size:Int)
- 按照指定数量分组,每个组有size个元素
val c = a.grouped(3).toList
- def hasDefiniteSize
- 检测序列是否存在有限的长度
a.hasDefiniteSize
- def head
- def headOption
- 返回Option类型对象
val c = a.headOption
- def indexOf()
- 返回索引,找到第一个就返回
val c = a.indexOf(3)
- def indexOf(e:T,f:Int)
- 返回索引,可以指定起始位置
val c= a.indexOf(3,3)
- def indexOfSlice(that:GenSeq,f:Int)
- 检测当前序列中是否包含另一个序列,并返回第一个匹配出现的元素的索引,可以指定位置
val c = a.indexOfSlice(b,1)
- def indexWhere(p:(T)=>Boolean)
- 返回当前序列中第一个满足条件的索引
val c = a.indexWhere({x:Int=> x<3})
- def indexWhere(p:(T)=>Boolean,f:Int)
- 返回当前序列中第一个满足条件的索引,可以指定开始位置
val c=a.indexWhere({x:Int=>x>3},4)
- def indices
- 返回当前序列索引集合
val c = a.indices
- def init
- 返回当前序列中不包含最后一个元素的序列
val c = a.init
- def inits
- 对序列进行多次init操作,直至为空
val c = a.inits
- def isDefinedAt(idx:Int)
- 判断序列中是否存在指定索引
val c = a.isDefinedAt(3)
- def isEmpty
- def isTraversableAgain
- def iterator
- 对序列中的每一个元素产生一个iterator
val c = a.iterator
- def last
- 取得序列中最后一个元素
val c = a.last
- def lastIndexOf(elem T)
- 取得序列中最后一个等于elem的元素的位置
val c = a.lastIndexOf(3)
- def lastIndexOf(e:T,end:Int)
- 取得序列中最后一个等于e的元素的位置,可以指定在end(包括)之前的元素中找
val c = a.lastIndexOf(1,3)
- def lastiIndexOfSlice(that:GenSeq)
- 判断当前序列中是否包含序列that,并返回最后一次出现该序列的位置处的索引
val c = a.lastIndexOfSlice(b)
- def lastIndexOfSlice(that:GenSeq,end:Int)
- 判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找
val c = a.lastIndexOfSlice(b,4)
- def lastIndexWhere(p:(T)=>Boolean)
- 返回当前序列中最后一个满足条件p的元素的索引
a.lastIndexWhere({x:Int=>x<3})
- def lastIndexWhere(p:(T)=>Boolean,x:Int)
- 返回当前 序列中最后一个满足条件p的元素的索引,可以指定在x之前的元素中查找
val c = a.lastIndexWhere({x:Int=>x<3},3)
- def lastOption
- 返回当前序列中最后一个对象
val c = a.lastOption
- def length
- 返回当前序列中元素的个数
val c = a.length
- def lengthComapre(len:Int)
- def map(f:(A)=>B)
- 对序列中的元素进行f操作
val c = a.map({x:Int=>x*10})
- def max
- def maxBy(f:(A)=>B)
- 返回序列中第一个符合条件的最大元素
val c = a.maxBy({x:Int=>x<3})
- def mkString
- 将所有元素组成一个字符串
val c = a.mkString
- def nonEmpty
- def padTo(len:Int,e:A)
- 后补齐序列,如果当前序列长度小于len,那么新产生的序列长度是len,多出的几个位值填充e
val c = a.padTo(10,3)
- def par
- 返回一个并行实现,产生并行序列,不能修改
val c = a.par
- def partition(p:(T)=>Boolean)
- 按条件将序列拆分成两个新序列 ,满足条件的放到第一个序列,其余放到第二个序列
val c = a.partition({x:Int=>x>3})
- def patch(from:Int,that:GenSeq,replaced:Int)
- 批量替换,从from开始,后面的replace数量的元素替换为that
val c = a.patch(0,a,3)
- def permutations
- 排列组合,内容可以相同,顺序不同,combinations不允许包含内容相同,即使顺序不一样
val c = a.permutations.toList
- def prefixLength(p:(T)=>Boolean)
- 给定一个条件p,返回一个前置数列的长度
val c = a.prefixLength({x:Int=>x<3})
- def product
- 返回所有元素的乘积的值
val c = a.product
- def reduce(op:(A,A)=>A)
- 同fold,不需要初始值
val c = a.reduce(_+_)
- def reduceLeft(op:(B,T)=>B)
- def reduceRight(op:(B,T)=>B)
- def reduceLeftOption(op:(B,T)=>B)
- def reduceRightOption(op:(B,T)=>B)
- def reverse
- def reverseIterator
- def reverseMap(f:(A)=>B)
- 同map方向相反
val c = a.reverseMap({x:Int=>x<3})
- def sameElements(that:GenIterable)
- 判断两个序是否顺序和对应位置上的元素都一样
val c = a.sameElements(b)
- def scan(z:B)(op:(B,B)=>B)
- 用法同fold,但是会把每一个计算值都放到新的集合中
val c = a.scan(10)(_+_)
- def scanLeft(z:B)(op:(B,T)=>B)
- def scanRight(z:B)(op:(B,T)=>B)
- def segmentLegth(p:(T)=>Boolean,form:Int)
- 从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度
val c = a.segmentLength({x:Int=>x<3},3)
- def seq
- def size
- def slice(from:Int,until:int)
- 取出当前序列中,from到until之间的片段
val c= a.slice(2,4)
- def sliding(size:Int)
- 从第一个元素开始,每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
val c= a.sliding(3)
- def sliding(size:Int,step:Int)
- 从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
该方法，可以设置步进 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始 val c= a.sliding(3,2)
- def sortBy(f:(T)=>B)
- 按照指定的排序规则排序
val c = a.sortBy(x:Int=>x)
- def sortWith(p:(T,T)=>Boolean)
- 自定义排序方法
val c = sortWith(_.compareTo(_)<0)
- def sorted
- 使用默认的排序规则对序列排序
val c = a.sorted
- def span(p:(T)=>Boolean)
- 分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合
val c = a.span({x:Int=>x<3})
- def splitAt(n:Int)
- 从指定位置开始,把序列拆分为两个集合
val c = a.splitAt(3)
- def startsWith(that:GenSeq,offset:Int)
- 从指定偏移处,是否以某个序列开始
val c = a.startsWith(b,3)
- def startsWith(that:GenSeq)
- 是否以某个序列开始
val c = a.startsWith(b)
- def stringPrefix
- 返回toString结果的前缀
val c = a.stringPrefix
- def subSequence(start:Int,end:Int)
- 返回start和end间的字符序列
val c = a.subSequence(1,3)
- def sum
- def tail
- 返回除了当前序列第一个元素的其他元素组成的序列\
val c = a.tail
- def take(n:Int)
- 返回当前序列中前n个元素组成的序列
val c = a.take(3)
- def takeRight(n:Int)
- 返回当前序列中,从右开始,选择n个元素组成的序列
val c = a.takeRight(3)
- def takeWhile(p:(T)=>Boolean)
- 返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
val c = a.takeWhile({x:Int=>x<3})
- def toArray
- def toBuffer
- def toIndexedSeq
- def toIterable
- def toIterator
- def toList
- def toMap
- def toSeq
- def toSet
- def toStream
- def toVector
- def transpose(implicit asArray: (T) ⇒ Array[U])
- 矩阵转换,二位数组行列转换
val c = Array(Array(1,3),Array(3,4))val d = c.transpose
- def union(that:collection.Seq[T])
- def unzip(implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2])
- 将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列
val c = Array(Array(1,3),Array(3,4))val d = c.unzip
- def unzip3(implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3])
- 将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列
val c = Array(("a","b","x"),("c","d","y"),("e","f","z"))val d =c.unzip3
- def update(i:Int,x:T)
- 将序列中索引处的元素更新为x
- `` a.update(3,3)`
- def updated(index:Int,e:A)
- 将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
val c = a.updated(3,3)
- def view(from:Int,until:Int)
- 返回 from 到 until 间的序列，不包括 until 处的元素
val c = a.view(1,3)
- def withFilter(p(T)=>Boolean)
- 根据p过滤元素
val c = a.withFilter({x:Int=>x<3})
- def zip(that: GenIterable[B])
- 将两个序列对应位置上的元素组成一个pair序列
val c = a.zip(b)
- def zipAll(that: collection.Iterable[B], thisElem: A, thatElem: B)
- 同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem
val c = a.zipAll(b,5,5)
- def zipwithIndex
- 序列中的每个元素和它的索引组成一个序列
val c = a.zipWithIndex
扫一扫
3642
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
