Scala常用Array函数(++ ~ drop)

Scala数组函数主要有以下这些:

++              dropRight         isDefinedAt          reduceLeftOption    takeRight
++:             dropWhile         isEmpty              reduceOption        takeWhile
+:              elemManifest      isTraversableAgain   reduceRight         to
/:              elemTag           iterator             reduceRightOption   toArray
:+              endsWith          last                 repr                toBuffer
:\              exists            lastIndexOf          reverse             toIndexedSeq
addString       filter            lastIndexOfSlice     reverseIterator     toIterable
aggregate       filterNot         lastIndexWhere       reverseMap          toIterator
andThen         find              lastOption           runWith             toList
apply           flatMap           length               sameElements        toMap
applyOrElse     flatten           lengthCompare        scan                toSeq
array           fold              lift                 scanLeft            toSet
canEqual        foldLeft          map                  scanRight           toStream
clone           foldRight         max                  segmentLength       toTraversable
collect         forall            maxBy                seq                 toVector
collectFirst    foreach           min                  size                transform
combinations    genericBuilder    minBy                slice               transpose
companion       groupBy           mkString             sliding             union
compose         grouped           nonEmpty             sortBy              unzip
contains        hasDefiniteSize   orElse               sortWith            unzip3
containsSlice   head              padTo                sorted              update
copyToArray     headOption        par                  span                updated
copyToBuffer    indexOf           partition            splitAt             view
corresponds     indexOfSlice      patch                startsWith          withFilter
count           indexWhere        permutations         stringPrefix        zip
deep            indices           prefixLength         sum                 zipAll
diff            init              product              tail                zipWithIndex
distinct        inits             reduce               tails
drop            intersect         reduceLeft           take

接下来我们详细讲解以下这些数组的用法。
++
数组的合并

var a=Array(1,2,3,4)
var b=Array(5,6,7,8)
var c=a++b
//结果
c: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)

++：
也是数组的合并，不过合并后的数组类型为冒号后面数组的类型。

var a=List(1,2,3,4)
//查看a集合的类型
a.getClass.getName
res59: String = scala.collection.immutable.$colon$colon
//创建一个LinkedList类型的b集合
import scala.collection.mutable.LinkedList
var b=LinkedList(5,6,7,8)
var c=a++:b
c: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4, 5, 6, 7, 8)
//c集合的类型为
c.getClass.getName
res58: String = scala.collection.mutable.LinkedList

可以看出c的集合的类型与b集合类型相同。
+：
在数组的前面加上一个元素

var c=0+:a
c: List[Int] = List(0, 1, 2, 3, 4)

/:
对数组中所有的元素进行相同的操作；

var a=Array(1,2,3,4)
var c=(10 /: a)(_+_)
//结果
c: Int = 20

斜杠前为定义的一个初始值，把初始值带入到数组a中，定义元素相加。为了方便理解大家可以看下这个执行过程：

var c=(10 /: a)((x,y)=>{println(x,y);x+y})
(10,1)
(11,2)
(13,3)
(16,4)
c: Int = 20

x的初始值为10，数组的第一个元素为y，即(10,1).
相加后11称为新的x，数组的第二个元素变为y，以此类推，得到最后的结果20。
:+
用法和**+:**类似，不过是在数组的最后添加一个元素。

a:+5
res65: Array[Int] = Array(1, 2, 3, 4, 5)

这里我并没有给其赋变量来接收返回值。系统会自动把返回值赋值给res。这里就是赋值给了res65.

res65
res66: Array[Int] = Array(1, 2, 3, 4, 5)

当然除了添加一个元素外，我们也可以添加一个数组：

a:+b
res67: Array[Any] = Array(1, 2, 3, 4, Array(5, 6))

不过添加时并不会把元素一个个加入进去，而是整个数组作为一个整体添加进去。
:\
用法同**/:，区别是:\是从右面开始运算，/:**是从左面开始运算

(a :\ 10)(_+_)
res68: Int = 20
var c=(a :\ 10)((x,y)=>{println(x,y);x+y})
(4,10)
(3,14)
(2,17)
(1,19)
c: Int = 20

addString

//用法
 def addString(b: StringBuilder): StringBuilder
 //对新的数组添加一个seq分隔符
 def addString(b: StringBuilder,sep: String): StringBuilder
 //首尾各加一个字符，中间用seq分隔符
 def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder

将数组中的元素逐个添加到b中。

scala> a
res69: Array[Int] = Array(1, 2, 3, 4)

scala> val b=new StringBuilder()
b: StringBuilder =

scala> a.addString(b)
res70: StringBuilder = 1234

scala> b
res71: StringBuilder = 1234

这里还有一个问题，就是输出的结果全都拼接在了一起，我们还可以在调用该函数时加上分隔符：

scala> val b2=new StringBuilder()
b2: StringBuilder =

scala> var c=a.addString(b2,",")
c: StringBuilder = 1,2,3,4

或者

var c=a.addString(b3,"{",",","}")
c: StringBuilder = {1,2,3,4}

aggregate
用作聚合计算。aggregate是柯里化方法，参数是两个方法。

scala> def fun1(x:Int,y:Int):Int={
     | println("fun1",x,y)
     | x+y
     | }
fun1: (x: Int, y: Int)Int

scala> def fun2(x:Int,y:Int):Int={
     | println("fun2",x,y)
     | x+y
     | }
fun2: (x: Int, y: Int)Int

此时使用aggregate只调用了fun1的方法，但是fun2不可省略。这里是计算初始值和元素的和。

a.aggregate(10)(fun1,fun2)
(fun1,10,1)
(fun1,11,2)
(fun1,13,3)
(fun1,16,4)
res77: Int = 20

使用par分区，先调用fun1，然后把fun1输出的结果作为fun2的输入，最后计算出唯一值。这里计算的是每个元素都在上10后，元素之间的和。

 a.par.aggregate(10)(fun1,fun2)
(fun1,10,1)
(fun1,10,3)
(fun1,10,2)
(fun1,10,4)
(fun2,11,12)
(fun2,13,14)
(fun2,23,27)
res82: Int = 50

对于上面的用法，我们也可以简写：

scala> a.aggregate(10)(_+_,_+_)
res0: Int = 20

scala> a.par.aggregate(10)(_+_,_+_)
res1: Int = 50

apply
取出指定索引处的元素

scala> a.apply(1)
res2: Int = 2

scala> a.apply(0)
res3: Int = 1

canEquak
判断两个对象是否可以比较

def canEqual(that: Any): Boolean

scala> a
res5: Array[Int] = Array(1, 2, 3, 4)

scala> var b=Array(4,5,6)
b: Array[Int] = Array(4, 5, 6)

scala> var c=Array("a","b","c")
c: Array[String] = Array(a, b, c)

scala> a.canEqual(b)
res6: Boolean = true

scala> a.canEqual(c)
res7: Boolean = true

charAt

def charAt(index: Int): Char

获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。

scala> var d=Array('a','b','c','d')
d: Array[Char] = Array(a, b, c, d)
scala> d.charAt(1)
res10: Char = b

clone
克隆一个副本

scala> a
res11: Array[Int] = Array(1, 2, 3, 4)

scala> var c=a.clone
c: Array[Int] = Array(1, 2, 3, 4)

collect
通过执行一个偏函数，得到一个新的数组对象。

scala> var d=List('a','b','c','d')
d: List[Char] = List(a, b, c, d)
//定义一个偏函数
scala> def fun:PartialFunction[Char,Int]={
     | case 'a'=>1
     | case 'b'=>2
     | case _=>0
     | }
fun: PartialFunction[Char,Int]
//collect调用
scala> d.collect(fun)
res12: Array[Int] = Array(1, 2, 0, 0)

collectFirst
在序列中查找第一个符合偏函数定义的元素，进行偏函数计算。

scala> d.collectFirst(fun)
res13: Option[Int] = Some(1)

返回的是一个Option对象。存在，则返回Some(n)，不存在返回None。

combinations

def combinations(n:Int):collection.Iterator

排列组合。选出所有不同元素的组合。参数n表示序列长度。

scala> a
res14: Array[Int] = Array(1, 2, 3, 4)

scala> a.combinations(2)
res15: Iterator[Array[Int]] = non-empty iterator

scala> a.combinations(2).toArray
res16: Array[Array[Int]] = Array(Array(1, 2), Array(1, 3), Array(1, 4), Array(2, 3), Array(2, 4), Array(3, 4))

contains

scala> a.contains(1)
res17: Boolean = true

containsSlice
序列中是否包含指定对象。返回的是布尔值。

scala> a
res18: Array[Int] = Array(1, 2, 3, 4)

scala> b
res19: Array[Int] = Array(4, 5, 6)

scala> a.containsSlice(b)
res20: Boolean = false

copyToArray
拷贝到数组。

def copyToArray(xs: Array[A]): Unit
copyToArray(xs: Array[A], start: Int): Unit
copyToArray(xs: Array[A], start: Int, len: Int): Unit

scala> var b:Array[Int]=new Array(4)
b: Array[Int] = Array(0, 0, 0, 0)

scala> a.copyToArray(b)

scala> b
res23: Array[Int] = Array(1, 2, 3, 4)

自动适应位数。

scala> var b:Array[Int]=new Array(6)
b: Array[Int] = Array(0, 0, 0, 0, 0, 0)
//拷贝到b，从数组下标为1的开始，拷贝a中前3个元素
scala> a.copyToArray(b,1,3)

scala> b
res30: Array[Int] = Array(0, 1, 2, 3, 0, 0)

copyToBuffer
拷贝到Buffer。再创建ArrayBuffer数组前，需要先导入可变的包。

scala> import scala.collection.mutable._
import scala.collection.mutable._

scala> var c:ArrayBuffer[Int]=ArrayBuffer()
c: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
scala> a.copyToBuffer(c)

scala> c
res33: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)

corresponds
判断两个数组的长度以及对应位置元素是否满足相应的条件。返回值是布尔值。

var a=Array(1,2,3,4)
var b=Array(5,6,7,8)
scala> a.corresponds(b)(_>_)
res39: Boolean = false

scala> a.corresponds(b)(_<_)
res40: Boolean = true

scala> a.corresponds(b)(_==_)
res41: Boolean=false

count
统计符合条件的元素个数

var a=Array(1,2,3,4)
scala> a.count(_>2)
res42: Int = 2

diff
计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回.

var a=Array(1,2,3,4)
var b=Array(3,4,5,6)
var c=a.diff(b)
//结果
c: Array[Int] = Array(1, 2)

distinct
去除当前数组中的重复元素，只保留一个

var c=Array(1,2,4,1,3,5,2,4)
c.distinct
//结果
res47: Array[Int] = Array(1, 2, 4, 3, 5)

drop

def drop(n:Int):Array[T]

去吃当前序列前n个元素，返回一个新的序列

scala> a
res48: Array[Int] = Array(1, 2, 3, 4)

scala> var b=a.drop(2)
b: Array[Int] = Array(3, 4)