scala 数组函数大全
什么是数组
Scala 语言中提供的数组是用来存储固定大小的同类型元素，跟Java中的数组很类似。
声明数组
//方式一
var arr:Array[String] = new Array[String](1,2,3,4)
//方式二
var arr = new Array[String](3)
处理数组
//声明一个数组对象
var arr:Array[String] = new Array[String](1,2,3,4)
// 读取第一个元素
var first = numbers(0)
// 替换第四个元素为100
numbers(3) = 9
// 所有元素都加2
var newNumbers = numbers.map(_ + 2)
数组函数大全
def ++[B](that: GenTraversableOnce[B]): Array[B]
作用：合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。
例如:
var a=Array(1,2,3,4)
var b=Array(5,6,7,8)
var c=a++b
println(c.mkString(","))
运行结果:
1,2,3,4,5,6,7,8
def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
作用：合并集合，并返回一个新的数组，两个加号后面的冒号代表右边操纵数的类型决定着返回结果的类型。
例如：
import scala.collection.mutable.LinkedList
var a=List(1,2,3,4)
var b=LinkedList(5,6,7,8)
var c = a ++: b
println(c.getClass().getName())
运行结果:
scala.collection.mutable.LinkedList
def +:(elem: A): Array[A]
作用：在数组前面添加一个元素，并返回新的对象。
例如：
var a=Array(1,2,3,4)
var b = 5 +: a
println(b.mkString(","))
运行结果:
5,1,2,3,4
def :+(elem: A): Array[A]
作用：在数组末尾添加一个元素，并返回新对象。
例如：
var a=Array(1,2,3,4)
var b = a :+ 5
println(b.mkString(","))
运行结果:
1,2,3,4,5
def /:[B](z: B)(op: (B, T) ⇒ B): B
作用：对数组中所有的元素从左至右进行相同的操作 ，foldLeft的简写。
例1：
var a=Array(1,2,3,4)
var b=(10 /: a)(_+_)
println(b)
运行结果:
20
例2：
var a=Array(1,2,3,4)
var c=(8 /: a)(_-_)
println(c)
运行结果:
-2
例3：
var a=Array(1,2,3,4)
var d=(5 /: a)(_*_)
println(d)
运行结果:
120
例4：
var a=Array(1,2,3,4)
var e=(240 /: a)(_/_)
println(e)
运行结果:
10
def : \ [B](z: B)(op: (T, B) ⇒ B): B
作用：对数组中所有的元素从右至左进行相同的操作 ，foldRight的简写。
例1：
var a=Array(1,2,3,4)
var b=(a :\ 10)(_+_)
println(b)
运行结果:
20
例2：
var a=Array(1,2,3,4)
var c=(a :\ 8)(_-_)
println(c)
运行结果:
6
例3：
var a=Array(1,2,3,4)
var d=(a :\ 3)(_*_)
println(d)
运行结果:
72
例4：
var a=Array(10,20)
var e=(a :\ 5)(_/_)
prinln(e)
运行结果:
10
def addString(b: StringBuilder): StringBuilder
作用：将数组中的元素逐个添加到字符串（StringBuilder）b中。
例如：
var a=Array(1,2,3,4)
var b=new StringBuilder()
var c=a.addString(b)
println(c)
运行结果:
1234
def addString(b: StringBuilder, sep: String): StringBuilder
作用：将数组中的元素逐个添加到字符串（StringBuilder）b中，每个元素用sep分隔符分开。
例如：
var a=Array(1,2,3,4)
var b=new StringBuilder()
var c=a.addString(b,",")
println(c)
运行结果:
1,2,3,4
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
作用：将数组中的元素逐个添加到字符串（StringBuilder）b中，每个元素用sep分隔符分开，并在首尾各加一个字符串。
例如：
var a=Array(1,2,3,4)
var b=new StringBuilder()
var c=a.addString(b,"{",",","}")
println(c)
运行结果:
{1,2,3,4}
def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
作用：聚合计算，aggregate是柯里化方法，参数是两个方法。
例如：
def seqno(m:Int,n:Int): Int ={
return m+n
}
def combine(m:Int,n:Int): Int ={
return m+n
}
val a = List(1,2,3,4)
val c = a.par.aggregate(5)(seqno,combine)
println("c:"+c)
上面过程可以简写为：
val c = a.par.aggregate(5)(_+_,_+_)
运行结果:
c:30
def andThen[C](k : scala.Function1[B, C]) :scala.PartialFunction[A, C]
作用：表示方法的连续调用，相当于嵌套函数 g(f(x)) （需满足第一个函数的返回值类型是第二个函数的输入值类型），与 compose 相反。
例如：
def f(a:Int) = {
println("3*"+a)
3*a
}
def g(b:Int) = {
println("4*"+b)
4*b
}
def r1 = f _ andThen g _
def r2 = f _ compose g _
println("调用andThen")
println(r1(2))
println("调用compose")
println(r2(2))
运行结果:
调用andThen
3*2
4*6
24
调用compose
4*2
3*8
24
def apply(i: Int): T
作用：取出指定索引处的元素。
例如：
var arr=Array(3,6,9,12,15,18)
var element=arr.apply(2)
println(element)
运行结果:
9
def applyOrElse[A1 <: A, B1 >: B](x : A1, default : scala.Function1[A1, B1]) : B1
作用： 接收2个参数，第一个是调用的参数，第二个是个回调函数。如果第一个调用的参数匹配，返回匹配的值，否则调用回调函数。（回调函数的输入类型需与调用参数类型一致）。
例如：
var func:PartialFunction[Int,String] = {
case x if(x%2==0) => "even"
}
var a=Array(1,2,3,4,5)
println(func.applyOrElse(a(0),{num:Int=>"odd"}))
println(func.applyOrElse(a(1),{num:Int=>"odd"}))
println(func.applyOrElse(a(2),{num:Int=>"odd"}))
println(func.applyOrElse(a(3),{num:Int=>"odd"}))
println(func.applyOrElse(a(4),{num:Int=>"odd"}))
运行结果:
odd
even
odd
even
odd
def array: Array[Int]
作用：返回一个数组。
例如：
var a=Array(1,2,3)
var b=new Array[ Int ] (3)
def canEqual(that: Any): Boolean
作用：判断两个对象是否可以进行比较。
例如：
var a=Array(1,2,3,4)
var b="scala"
var c=List(7,8,9,10)
print(a.canEqual(b))
print(a.canEqual(c))
运行结果:
true
true
def charAt(index: Int): Char
作用：获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。
例如：
var arr=Array('x','y','z')
var chr=arr.charAt(0)
println(chr)
运行结果:
x
def clone(): Array[T]
作用：创建一个潜拷贝副本。
例如：
var arc=Array("scala","hive",Array("html","js"),"hadoop")
//得到一个副本
var copy=arc.clone()
//改变数组arc中元素的值
arc(2)=Array("html","css")
说明：
//src
Array(scala, hive, Array(html, css), hadoop)
//copy
Array(scala, hive, Array(html, js), hadoop)
def collect[B](pf: PartialFunction[A, B]): Array[B]
作用：通过执行一个并行计算（偏函数），得到一个新的数组对象。
例如：
//定义一个偏函数，把数组的小写a转换为大写的A，其他的元素不作处理
val fun:PartialFunction[Char,Char] = {
case 'a' => 'A'
case x => x
}
val arr = Array('a','b','c')
val newarr = arr.collect(fun)
println(newarr.mkString(","))
运行结果:
A,b,c
def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
作用：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算。
例如：
var arr = Array(5,10,"g","k")
val fun:PartialFunction[Any,Int] = {
case x:Int => x+2
}
val newarr = arr.collectFirst(fun)
println(newarr.mkString(","))
上面过程可以简写为：
val newarr = arr.collectFirst({case x:Int => x+2})
运行结果:
7
def combinations(n: Int): collection.Iterator[Array[T]]
作用：根据集合元素排列组合成序列长度为n的集合迭代器。
例如：
var arr=Array('a','b','c','d')
var it=arr.combinations(2)
it.foreach((itme)=>println(item.mkString(",")))
运行结果:
a,b
a,c
a,d
b,c
b,d
c,d
def companion:scala.collection.mutable.IndexedSeq
作用：表示方法的连续调用，相当于嵌套函数 g(f(x)) （需满足第二个函数的返回值类型是第一个函数的输入值类型），与andThen 相反，参考andThen用法。
def contains[A1 >: A](elem: A1): Boolean
作用：判断序列中是否包含指定对象。
例如：
var arr=Array("hive","hadoop","hbase","zookeeper")
var flag1=arr.contains("hadoop")
var flag2=arr.contains("html")
println(flag1)
println(flag2)
运行结果:
true
false
def containsSlice[B](that: GenSeq[B]): Boolean
作用：判断当前序列中是否包含另一个序列。
例如：
var a=Array(1,2,3,4,5,6)
var b=Array(2,3)
var c=Array(3,2)
println(a.containsSlice(b))
println(a.containsSlice(c))
运行结果:
true
false
def copyToArray(xs: Array[A]): Unit
作用：拷贝数组。
例如：
var a = Array('a', 'b', 'c','d','e')
var b : Array[Char] = new Array(10)
a.copyToArray(b)
println(b.mkString(","))
运行结果:
a,b,c,d,e, , , , ,
def copyToArray(xs: Array[A], start: Int): Unit
作用：拷贝数组,指定被复制数组的位置。
例如：
var a = Array('a', 'b', 'c','d','e')
var b : Array[Char] = new Array(10)
a.copyToArray(b,3)
println(b.mkString(","))
运行结果:
, , ,a,b,c,d,e, ,
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
作用：拷贝数组,指定被复制数组的位置和拷贝的元素数量。
例如：
var a = Array('a', 'b', 'c','d','e')
var b : Array[Char] = new Array(10)
a.copyToArray(b,3)
println(b.mkString(","))
a.copyToArray(b,6)
println(b.mkString(","))
运行结果:
, , ,a,b,c, , , ,
, , ,a,b,c,d,e, ,
def copyToBuffer[B >: A](dest: Buffer[B]): Unit
作用：将数组中的内容拷贝到ArrayBuffer中
例如：
import scala.collection.mutable.ArrayBuffer
var a=Array('a','b','c')
var b:ArrayBuffer[Char] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(","))
运行结果:
a,b,c
def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
作用：判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true。
例1：
var a=Array(1,2,3,4)
var b=Array(5,6,7,8)
println(a.corresponds(b)(_<_))
运行结果:
true
例2：
var a=Array(3,7,4,8)
var b=Array(5,1,2,6)
println(a.corresponds(b)(_<_))
运行结果:
false
def count(p: (T) ⇒ Boolean): Int
作用：计算符合条件的元素个数。
例如：
var a =Array(3,1,2,5,4,8,6,7)
println(a.count(_>4))
运行结果:
4
def diff(that: collection.Seq[T]): Array[T]
作用：计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回。
例如：
var a = Array(1,2,3,4,5)
var b = Array(4,5,6,7,8)
var c = a.diff(b)
println(c.mkString)
运行结果:
1,2,3
def distinct: Array[T]
作用：去除当前集合中重复的元素，只保留其中一个。
例如：
var a = Array(5,3,6,4,1,2,6,2,3,7,2,1,1,10)
var b = a.distinct
println(b.mkString(","))
运行结果:
5,3,6,4,1,2,7,10
def drop(n: Int): Array[T]
作用：将当前序列中从部头去除n个元素，作为一个新序列返回。
例如：
var a = Array(7,2,3,4,1,5,6)
var b = a.drop(2)
println(b.mkString(","))
运行结果:
3,4,1,5,6
def dropRight(n: Int): Array[T]
作用：将当前序列中从尾部去除n个元素，作为一个新序列返回。
例如：
var a = Array(7,2,3,4,1,5,6)
var b = a.dropRight(2)
println(b.mkString(","))
运行结果:
7,2,3,4,1
def dropWhile(p: (T) ⇒ Boolean): Array[T]
作用：去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组。
例如：
var a = Array(7,2,3,4,1,5,6)
var b = a.dropWhile( {x:Int => x < 7} )
var c = a.dropWhile( {x:Int => x > 1 } )
println(b.mkString(","))
println(c.mkString(","))
运行结果:
7,2,3,4,1,5,6
1,5,6
def endsWith[B](that: GenSeq[B]): Boolean
作用： 判断是否以指定序列作为结尾。
例如：
var a = Array(1,2,3,4)
var b = Array(3,4)
println(a.endsWith(b))
运行结果:
true
def exists(p: (T) ⇒ Boolean): Boolean
作用： 判断当前数组是否包含符合条件的元素。
例如：
var a = Array(1,2,3,4,5,6,7,8)
println(a.exists( {x:Int => x==5} ))
println(a.exists( {x:Int => x>8} ))
运行结果:
true
false
def filter(p: (T) ⇒ Boolean): Array[T]
作用： 取得当前数组中符合条件的元素，组成新的数组返回。
例如：
var a = Array(1,2,3,4)
var b = a.filter( {x:Int => x> 2} )
println(b.mkString(","))
运行结果:
3,4
def filterNot(p: (T) ⇒ Boolean): Array[T]
作用： 取得当前数组中不符合条件的元素，组成新的数组返回。
例如：
var a = Array(1,2,3,4)
var b = a.filterNot( {x:Int => x> 2} )
println(b.mkString(","))
运行结果:
1,2
def find(p: (T) ⇒ Boolean): Option[T]
作用： 查找第一个符合条件的元素。
例如：
var a = Array(1,2,3,4,5,6,7,8)
var b = a.find( {x:Int => x>5} )
println(b.get)
运行结果:
6
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
作用：对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类。
例如：
var a = Array(1,2,3,4)
var b = a.flatMap(x=>1 to x)
var c = a.flatMap(x=>2 to x)
println(b.mkString(","))
println(c.mkString(","))
运行结果:
1,1,2,1,2,3,1,2,3,4
2,2,3,2,3,4
def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
作用： 将n(n>1)维数组的所有元素联合在一起，形成一个n-1维数组返回,并且n维数组中的元素的维度数必须一致。
例如：
var a = Array(Array(1,2,3,4),Array(5,6,7,8))
var b = a.flatten
println(b.mkString(","))
运行结果:
1,2,3,4,5,6,7,8
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
作用：对数组中所有的元素从左至右进行相同的操作。
例如：
var a=Array(1,2,3,4)
var b=(a :\ 10)(_+_)
println(b)
运行结果:
20
def foldLeft[B](z: B)(op: (B, T) ⇒ B): B
作用： 从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) ⇒ B): B
例如：
def seqno(m:Int,n:Int): Int ={
m+n
}
var a=Array(1,2,3,4)
var b=a.foldLeft(5)(seqno)
println(b)
运行结果:
15
def foldRight[B](z: B)(op: (B, T) ⇒ B): B
作用： 从右到左计算，简写方式：def :[B](z: B)(op: (T, B) ⇒ B): B
例如：
def seqno(m:Int,n:Int): Int ={
m-n
}
var a=Array(1,2,3,4)
var b=a.foldRight(5)(seqno)
println(b)
运行结果:
3
def forall(p: (T) ⇒ Boolean): Boolean
作用： 检测序列中的元素是否都满足条件p，如果序列为空，返回true。
例如：
val a = Array(1,2,3,4,5,6,7,8)
val b = a.forall( {x:Int => x>0})
val c = a.forall( {x:Int => x>3})
println(b)
println(c)
运行结果:
true
false
def foreach(f: (A) ⇒ Unit): Unit
作用： 遍历序列中的元素，进行f操作。
例如：
var a = Array(1,2,3,4)
a.foreach(x => println(x+5))
运行结果:
6
7
8
9
def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
作用：按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列。
例如：
var a = Array(1,2,3,4,5,6,7,8,9,10,11,12)
var b = a.groupBy( x => x match {
case x if(x%3==0) => "00"
case x if(x%3==1) => "01"
case x if(x%3==2) => "02"
})
b.foreach(x=>println(x._2.mkString(",")))
运行结果:
3,6,9,12
2,5,8,11
1,4,7,10
def grouped(size: Int): collection.Iterator[Array[T]]
作用：按指定数量分组，每组有 size 数量个元素，返回一个集合。
例如：
var a = Array(1,2,3,4,5,6,7)
var b = a.grouped(3).toList
b.foreach((x) => println(x.mkString(",")))
运行结果:
1,2,3
4,5,6
7
def hasDefiniteSize: Boolean
作用：检测序列是否存在有限的长度，对应Stream这样的流数据，返回false。
例如：
var a = Array(1,2,3,4,5)
println(a.hasDefiniteSize)
运行结果:
true
def head: T
作用：返回序列的第一个元素，如果序列为空，将引发错误。
例如：
var a = Array(1,2,3,4,5)
println(a.head)
运行结果:
1
def headOption: Option[T]
作用：返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None。
例如：
var a = Array(1,2,3,4,5,6)
println(a.headOption)
运行结果:
Some(1)
def indexOf(elem: T): Int
作用：返回elem在序列中的索引，找到第一个就返回。
例如：
var a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3))
运行结果:
2
def indexOf(elem: T, from: Int): Int
作用：返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回。
例如：
var a = Array(1,2,3,4,2,6)
println(a.indexOf(2,2))
运行结果:
4
def indexOfSlice[B >: A](that: GenSeq[B]): Int
作用：检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引。
例如：
var a = Array(5,3,4,3,4,6)
var b = Array(3,4)
println(a.indexOfSlice(b))
运行结果:
1
def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
作用：检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始。
例如：
var a = Array(5,3,4,3,4,6)
var b = Array(3,4)
println(a.indexOfSlice(b,3))
运行结果:
3
def indexWhere(p: (T) ⇒ Boolean): Int
作用：返回当前序列中第一个满足 p 条件的元素的索引。
例如：
var a = Array(1,2,3,4)
println(a.indexWhere( {x:Int => x<3}))
运行结果:
0
def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
作用：返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始。
例如：
var a = Array(1, 2, 3, 4, 5, 6)
println(a.indexWhere( {x:Int => x>3},4))
运行结果:
4
def indices: collection.immutable.Range
作用：返回当前序列索引集合
例如：
var a = Array(10,2,3,40,5)
var b = a.indices
println(b.mkString(","))
运行结果:
4
def init: Array[T]
作用：返回当前序列中不包含最后一个元素的序列
例如：
var a = Array(6,2,3,6,5)
var b = a.init
println(b.mkString(","))
运行结果:
6,2,3,6
def inits: collection.Iterator[Array[T]]
作用：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象
例如：
var a = Array(1, 2, 3, 4, 5)
var b = a.inits.toList
for(i <- 1 to b.length){
val s = "第%d个值：%s"
println(s.format(i,b(i-1).mkString(",")))
}
运行结果:
第1个值：1,2,3,4,5
第2个值：1,2,3,4
第3个值：1,2,3
第4个值：1,2
第5个值：1
第6个值
def intersect(that: collection.Seq[T]): Array[T]
作用：取两个集合的交集。
例如：
var a = Array(1,2,3,4,5)
var b = Array(3,4,5,6,7)
var c = a.intersect(b)
println(c.mkString(","))
运行结果:
3,4
def isDefinedAt(idx: Int): Boolean
作用：判断序列中是否存在指定索引。
例如：
var a = Array(1,2,3,4,5,6,7,8,9,10)
println(a.isDefinedAt(1))
println(a.isDefinedAt(10))
运行结果:
true
false
def isEmpty: Boolean
作用：判断当前序列是否为空。
例如：
var a = Array(1,2,3,4,5)
println(a.isEmpty)
运行结果:
false
def isTraversableAgain: Boolean
作用：判断序列是否可以反复遍历，该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回 false，除非被复写。
例如：
var a=Array(1,2,3,4,5)
println(a.isTraversableAgain)
运行结果:
true
def iterator: collection.Iterator[T]
作用：对序列中的每个元素产生一个iterator。
例如：
var a = Array(1, 2, 3, 4, 5)
var b = a.iterator
b.foreach(x=>println(x))
运行结果:
1
2
3
4
5
def last: T
作用：取得序列中最后一个元素。
例如：
var a = Array(1,2,3,4,5)
println(a.last)
运行结果:
5
def lastIndexOf(elem: T): Int
作用：取得序列中最后一个等于 elem 的元素的位置。
例如：
var a = Array(1,4,2,3,4,5)
println(a.lastIndexOf(4))
运行结果:
4
def lastIndexOf(elem: T, end: Int): Int
作用：取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前（包括）的元素中查找。
例如：
var a = Array(1, 4, 2, 3, 4, 5)
println(a.lastIndexOf(4,3))
运行结果:
1
def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
作用：判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引。
例如：
var a = Array(1, 4, 2, 3, 4, 5, 1, 4)
var b = Array(1, 4)
println(a.lastIndexOfSlice(b))
运行结果:
6
def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
作用：判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找。
例如：
var a = Array(1, 4, 2, 3, 4, 5, 1, 4)
var b = Array(1, 4)
println(a.lastIndexOfSlice(b,4))
运行结果:
0
def lastIndexWhere(p: (T) ⇒ Boolean): Int
作用：返回当前序列中最后一个满足条件 p 的元素的索引。
例如：
var a = Array(4, 4, 5, 3, 4, 5, 1, 4)
var b = Array(4, 5)
println(a.lastIndexWhere( {x:Int => x<2}))
运行结果:
6
def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
作用：返回当前序列中最后一个满足条件 p 的元素的索引，可以指定在 end 之前（包括）的元素中查找。
例如：
var a = Array(4, 4, 5, 3, 4, 5, 1, 4)
var b = Array(4, 5)
println(a.lastIndexWhere( {x:Int => x>3},6))
println(a.lastIndexWhere( {x:Int => x>3},2))
运行结果:
5
2
def lastOption: Option[T]
作用：返回当前序列中最后一个对象。
例如：
var a = Array(1,2,3,4,5)
println(a.lastOption)
运行结果:
Some(5)
def length: Int
作用：返回当前序列中元素个数。
例如：
var a = Array(1,2,3,4,5)
println(a.length)
运行结果:
5
def lengthCompare(len: Int): Int
作用：比较序列的长度和参数 len，根据二者的关系返回不同的值，比较规则是。
例如：
var a=Array(1,2,3,4,5,6)
print(a.lengthCompare(5))
print(a.lengthCompare(6))
print(a.lengthCompare(7))
运行结果:
1
0
-1
def map[B](f: (A) ⇒ B): Array[B]
作用：对序列中的元素进行 f 操作。
例如：
var a = Array(1, 2, 3, 4, 5)
var b = a.map( {x:Int => x+5})
println(b.mkString(","))
运行结果:
6,7,8,9,10
def max: A
作用：返回序列中最大的元素。
例如：
var a = Array(1, 2, 3, 4, 5)
println(a.max)
运行结果:
5
def maxBy[B](f: (A) ⇒ B): A
作用：返回序列中符合条件的第一个元素。
例如：
var a = Array(1, 2, 3, 4, 5)
println(a.maxBy( {x:Int => x > 2}))
运行结果:
3
def min : A
作用：返回序列中最大的元素。
例如：
var a = Array(1, 2, 3, 4, 5)
println(a.min)
运行结果:
1
def minBy[B](f: (A) ⇒ B): A
作用： 返回序列中不符合条件的第一个元素(找不到满足条件的元素返回一个元素)。
例如：
var a = Array(1,3,2,4,5,7,6)
print(a.minBy(x=>x<4))
print(a.minBy(x=>x<6))
print(a.minBy(x=>x>1))
print(a.minBy(x=>x>6))
运行结果:
4
7
1
1
def mkString: String
作用：将所有元素组合成一个字符串。
例如：
var a = Array(1, 2, 3, 4, 5)
println(a.mkString)
运行结果:
12345
def mkString(sep: String): String
作用：将所有元素组合成一个字符串，以 sep 作为元素间的分隔符。
例如：
var a = Array(1, 2, 3, 4, 5)
println(a.mkString("|"))
运行结果:
1|2|3|4|5
def mkString(start: String, sep: String, end: String): String
作用：将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾。
例如：
var a = Array(1, 2, 3, 4, 5)
println(a.mkString("{",",","}"))
运行结果:
{1,2,3,4,5}
def nonEmpty: Boolean
作用：判断序列不是空。
def orElse[B >: A](alternative : => scala.Option[B]) : scala.Option[B]
作用：返回Option里的Some或从参数传递进去的Some。
例如：
var a = Some("Hello Scala")
println(a.orElse(null))
var b = None
println(b.orElse(Some("Just do it")))
运行结果:
Some(Hello Scala)
Some(Just do it)
def padTo(len: Int, elem: A): Array[A]
作用：后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列。
例如：
var a = Array(1,2,3,4,5)
var b = a.padTo(10,9)
println(b.mkString(","))
运行结果:
1,2,3,4,5,9,9,9,9,9
def par: ParArray[T]
作用：返回一个并行实现，产生的并行序列，不能被修改。
例如：
var a = Array(1, 2, 3, 4, 5)
var b = a.par
说明:
得到一个ParArray(1, 2, 3, 4, 5)
def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
作用：按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分。
例如：
var a = Array(1, 2, 3, 4, 5)
var b:(Array[Int],Array[Int]) = a.partition( {x:Int => x % 2 == 0})
println(b._1.mkString(","))
println(b._2.mkString(","))
运行结果:
2,4
1,3,5
def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
作用：批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that。
例如：
var a = Array(1,1,2,2,3,3,4,4,5,5,6,6)
var b = Array(3,4,5,6,7,8)
var c = a.patch(2,b,3)
println(c.mkString(","))
运行结果:
1,1,3,4,5,6,7,8,3,4,4,5,5,6,6
def permutations: collection.Iterator[Array[T]]
作用：排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样。
例如：
var a = Array(1, 2, 3, 4)
var b = a.permutations
b.foreach(x=>println(x.mkString(",")))
运行结果:
1,2,3,4
1,2,4,3
1,3,2,4
1,3,4,2
1,4,2,3
1,4,3,2
2,1,3,4
2,1,4,3
2,3,1,4
2,3,4,1
2,4,1,3
2,4,3,1
3,1,2,4
3,1,4,2
3,2,1,4
3,2,4,1
3,4,1,2
3,4,2,1
4,1,2,3
4,1,3,2
4,2,1,3
4,2,3,1
4,3,1,2
4,3,2,1
如果是combinations，结果有所不同
例如：
var a = Array(1, 2, 3, 4)
var b = a.combinations(2)
var c = a.combinations(3)
var d = a.combinations(4)
b.foreach(x=>println(x.mkString(",")))
c.foreach(x=>println(x.mkString(",")))
d.foreach(x=>println(x.mkString(",")))
运行结果:
1,2
1,3
1,4
2,3
2,4
3,4
1,2,3
1,2,4
1,3,4
2,3,4
1,2,3,4
def prefixLength(p: (T) ⇒ Boolean): Int
作用：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足p。
例如：
var a = Array(1,2,3,4,1,2,3,4)
var b = a.prefixLength( {x:Int => x<3})
运行结果:
2
def product: A
作用：返回所有元素乘积的值。
例如：
var a = Array(1,2,3,4,5)
var b = a.product
print(b)
运行结果:
120
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
作用：类似于fold方法，不需要初始值。
例如：
var a = Array(1,'a',2,'b',3,'c',4,'d',5,'e')
//a被强制转换成 a: Array[Int] = Array(1, 97, 2, 98, 3, 99, 4, 100, 5, 101)
var b = a.reduce(_+_)
println(b)
运行结果:
510
def reduceLeft[B >: A](op: (B, T) ⇒ B): B
作用：从左向右计算。
def reduceRight[B >: A](op: (T, B) ⇒ B): B
作用：从右向左计算。
def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
作用：计算Option，参考reduceLeft。
def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
作用：计算Option，参考reduceRight。
def repr : Repr
作用：repr() 函数将对象转化为供解释器读取的形式。
例如：
var a = Map(1 -> "a",2 -> "b")
println(a.repr)
运行结果:
Map(1 -> a, 2 -> b)
def reverse: Array[T]
作用：反转序列。
例如：
var a = Array(1,2,3,4,5)
var b = a.reverse
println(b.mkString(","))
运行结果:
5,4,3,2,1
def reverseIterator: collection.Iterator[T]
作用：反向生成迭代。
def reverseMap[B](f: (A) ⇒ B): Array[B]
作用：同map方向相反。
例如：
var a = Array(1,2,3,4,5)
var b = a.reverseMap( {x:Int => x-1} )
println(b.mkString(","))
运行结果:
4,3,2,1,0
def runWith[U](action : scala.Function1[B, U]) : scala.Function1[A, scala.Boolean]
作用：执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action
例如：
var pf: PartialFunction[Int, Int] = { case m: Int if m % 2 == 1=> m * 2 }
pf.runWith(println)(3) //返回true
pf.runWith(println)(2) //返回false
运行结果:
6
def sameElements(that: GenIterable[A]): Boolean
作用：判断两个序列是否顺序和对应位置上的元素都一样。
var a = Array(1,2,3,4,5)
var b = Array(1,2,3,4,5)
println(a.sameElements(b))
var c = Array(1,2,3,5,4)
println(a.sameElements(c))
运行结果:
true
false
def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
作用：用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值。
例如：
var a = Array(1,2,3,4,5)
var b = a.scan(5)(_+_)
println(b.mkString(","))
运行结果:
5,6,8,11,15,20
def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
作用：从左向右计算。
def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
作用：从右向左计算。
def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
作用：从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度。
例如：
var a = Array(1,2,3,3,6,4,2,2,4,5)
var b = a.segmentLength( {x:Int => x < 5},1)
运行结果:
3
def seq: collection.mutable.IndexedSeq[T]
作用：产生一个引用当前序列的 sequential 视图。
例如：
var a=Array(1,2,3,4,5)
a.seq
//产生一个scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5)
def size: Int
作用：序列元素个数，同length。
def slice(from: Int, until: Int): Array[T]
作用：取出当前序列中，from 到 until 之间的片段。
例如：
var a = Array(1,2,3,4,5)
var b = a.slice(1,3)
println(b.mkString(","))
运行结果:
2,3
def sliding(size: Int): collection.Iterator[Array[T]]
作用：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止。
例如：
var a = Array(1,2,3,4,5)
var b = a.sliding(3).toList
for(i<-0 to b.length - 1){
println(b(i).mkString(","))
}
运行结果:
1,2,3
2,3,4
3,4,5
def sliding(size: Int, step: Int): collection.Iterator[Array[T]]
作用：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
该方法，可以设置步进 step，第一个元素组合完后，下一个从上一个元素位置+step后的位置处的元素开始。
例如：
var a = Array(1,2,3,4,5,6)
var b = a.sliding(3,2).toList
for(i<-0 to b.length - 1){
println(b(i).mkString(","))
}
运行结果:
1,2,3
3,4,5
5,6
def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
作用：按指定的排序规则排序。
例如：
var a = Array(7,2,8,1,4,6,5,3)
var b = a.sortBy( {x:Int => x})
var c = a.sortBy( {x:Int => x>3})
println(b.mkString(","))
println(c.mkString(","))
运行结果:
1,2,3,4,5,6,7,8
2,1,3,7,8,4,6,5
def sortWith(lt: (T, T) ⇒ Boolean): Array[T]
作用：自定义排序方法lt。
例如：
var a = Array(7,2,8,1,4,6,5,3)
var b = a.sortWith(_.compareTo(_) > 0)
println(b.mkString(","))
运行结果:
8,7,6,5,4,3,2,1
def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]
作用：使用默认的排序规则对序列排序。
例如：
var a = Array(7,2,8,1,4,6,5,3)
var b = a.sorted
println(b.mkString(","))
运行结果:
1,2,3,4,5,6,7,8
def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
作用：分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合。
例如：
var a = Array(7,2,8,1,4,6,5,3)
var b = a.span( {x:Int => x > 2})
println(b._1.mkString(","))
println(b._2.mkString(","))
运行结果:
7
2,8,1,4,6,5,3
def splitAt(n: Int): (Array[T], Array[T])
作用：从指定位置开始，把序列拆分成两个集合。
例如：
var a = Array(7,2,8,1,4,6,5,3)
var b = a.splitAt(2)
println(b._1.mkString(","))
println(b._2.mkString(","))
运行结果:
7,2
8,1,4,6,5,3
def startsWith[B](that: GenSeq[B], offset: Int): Boolean
作用：从指定偏移处，是否以某个序列开始。
例如：
var a = Array(0,1,2,3,4,5)
var b = Array(1,2)
println(a.startsWith(b,1))
运行结果:
true
def startsWith[B](that: GenSeq[B]): Boolean
作用：是否以某个序列开始。
例如：
var a = Array(1,2,3,4,5)
var b = Array(1,2)
println(a.startsWith(b))
运行结果:
true
def stringPrefix: String
作用：返回 toString 结果的前缀。
例如：
var a = Array(0,1,2,3,4,5,6,7)
println(a.toString())
var b = a.stringPrefix
println(b)
运行结果:
//[[email protected]
//[I
def subSequence(start: Int, end: Int): CharSequence
作用：返回 start 和 end 间的字符序列。
例如：
var chars = Array('a','b','c','d')
var b = chars.subSequence(1,3)
println(b.toString)
运行结果:
bc
def sum: A
作用：序列求和，元素需为Numeric[T]类型。
例如：
var a = Array(1,2,3,4,5)
var b = a.sum
prinln(b)
运行结果:
15
def tail: Array[T]
作用：返回除了当前序列第一个元素的其它元素组成的序列。
例如：
var a = Array(1,2,3,4,5)
var b = a.tail
println(b.mkString(","))
运行结果:
2,3,4,5
def tails: Iterator[Array[Int]]
作用：排列组合，返回一个数组迭代器。
例如：
var a=Array(12,3,5,6)
var b=a.tails.toList
val b = a.tails.toList
for (i <- 0 until b.length) {
val s = "第 %d 个值: %s"
println(s.format(i + 1, b(i).mkString(",")))
}
运行结果:
第 1 个值: 12,3,5,6
第 2 个值: 3,5,6
第 3 个值: 5,6
第 4 个值: 6
第 5 个值:
def take(n: Int): Array[T]
作用：返回当前序列中前 n 个元素组成的序列。
例如：
var a = Array(1,2,3,4,5)
var b = a.take(3)
println(b.mkString(","))
运行结果:
1,2,3
def takeRight(n: Int): Array[T]
作用：返回当前序列中，从右边开始，选择 n 个元素组成的序列。
例如：
var a = Array(1,2,3,4,5)
var b = a.takeRight(3)
println(b.mkString(","))
运行结果:
3,4,5
def takeWhile(p: (T) ⇒ Boolean): Array[T]
作用：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列。
例如：
var a = Array(1,2,3,4,5)
var b = a.takeWhile( {x:Int => x < 3})
println(b.mkString(","))
运行结果:
1,2
def toArray: Array[A]
作用：转换成 Array 类型。
def toBuffer[A1 >: A]: Buffer[A1]
作用：转换成 Buffer 类型。
def toIndexedSeq: collection.immutable.IndexedSeq[T]
作用：转换成 IndexedSeq 类型。
def toIterable: collection.Iterable[T]
作用：转换成可迭代的类型。
def toIterator: collection.Iterator[T]
作用：同 iterator 方法。
def toList: List[T]
作用：同 List 类型。
def toMap[T, U]: Map[T, U]
作用：同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据。
例如：
var chars = Array(("a","b"),("c","d"),("e","f"))
var b = chars.toMap
println(b)
运行结果：
Map(a -> b, c -> d, e -> f)
def toSeq: collection.Seq[T]
作用：同 Seq 类型。
def toSet[B >: A]: Set[B]
作用：同 Set 类型。
def toStream: collection.immutable.Stream[T]
作用：同 Stream 类型。
def toVector: Vector[T]
作用：同 Vector 类型。
def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
作用：矩阵转换，二维数组行列转换。
例如：
var chars = Array(Array("a","b"),Array("c","d"),Array("e","f"))
var b = chars.transpose
b.foreach(x=>println(x.mkString(",")))
运行结果：
a,c,e
b,d,f
def union(that: collection.Seq[T]): Array[T]
作用：联合两个序列，同操作符 ++。
例如：
var a = Array(1,2,3,4,5)
var b = Array(6,7)
var c = a.union(b)
println(c.mkString(","))
运行结果：
1,2,3,4,5,6,7
def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
作用：将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列。
例如：
var chars = Array(("a","b"),("c","d"))
var b = chars.unzip
println(b._1.mkString(","))
println(b._2.mkString(","))
运行结果：
a,c
b,d
def unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
作用：将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列。
例如：
var chars = Array(("a","b","x"),("c","d","y"),("e","f","z"))
var b = chars.unzip3
println(b._1.mkString(","))
println(b._2.mkString(","))
println(b._3.mkString(","))
运行结果：
a,c,e
b,d,f
x,y,z
def update(i: Int, x: T): Unit
作用：将序列中 i 索引处的元素更新为 x。
例如：
var a = Array(1,2,3,4,5,6)
a.update(2,7)
println(a.mkString(","))
运行结果：
1,2,7,4,5,6
def updated(index: Int, elem: A): Array[A]
作用：将序列中 i 索引处的元素更新为 x ,并返回替换后的数组。
例如：
var a = Array(1,2,3,4,5,6)
var b = a.updated(2,7)
println(b.mkString(","))
运行结果：
1,2,7,4,5,6
def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
作用：返回 from 到 until 间的序列，不包括 until 处的元素。
例如：
var a = Array(1,2,3,4,5,6)
var b = a.view(2,5)
println(b.mkString(","))
运行结果：
3,4,5
def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
作用：根据条件 p 过滤元素。
例如：
var a = Array(1,2,3,4,5,6)
var b = a.withFilter( {x:Int => x>3}).map(x=>x)
println(b.mkString(","))
运行结果：
4,5,6
def zip[B](that: GenIterable[B]): Array[(A, B)]
作用：将两个序列对应位置上的元素组成一个pair序列。
例如：
var a = Array(1,2,3,4,5,6)
var b = Array(5,4,3,2,1,0)
var c = a.zip(b)
println(c.mkString(","))
运行结果：
(1,5),(2,4),(3,3),(4,2),(5,1),(6,0)
def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
作用：同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem。
例1：
var a = Array(1,2,3,4,5,6,7)
var b = Array(5,4,3,2,1)
var c = a.zipAll(b,9,8)
运行结果：
(1,5),(2,4),(3,3),(4,2),(5,1),(6,8),(7,8)
例2：
var a = Array(1,2,3,4)
var b = Array(5,4,3,2,1)
var c = a.zipAll(b,9,8)
运行结果：
(1,5),(2,4),(3,3),(4,2),(9,1)
def zipWithIndex: Array[(A, Int)]
作用：序列中的每个元素和它的索引组成一个序列。
例如：
var a = Array(5,16,10,9,24,12)
var b = a.zipWithIndex
println(b.mkString(","))
运行结果：
(5,0),(16,1),(10,2),(9,3),(24,4),(12,5)