在scala中，Array有大量的方法。定义一个数组arr后，输入arr.后按下tab，可以得到大量的方法。

•  ++

        合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。

var a = Array(2,1)
var b = Array(3,4)
var c = a ++ b
var c = a.++(b)

        结果如下：

• ++：

        这个方法同上一个方法类似，两个加号后面多了一个冒号，但是返回数组类型与冒号右侧数组相同。

 val a = List(1,2)val b = scala.collection.mutable.LinkedList(3,4)val c = a ++: bval c = a.++:(b)

        运行结果如下：

• +：

        在数组前面添加一个元素，并返回新的对象，下面添加一个元素。

var a = Array(1,2)
var b = 0 +: a

        运行结果如下：

• :+

        同上面的方法想法，在数组末尾添加一个元素，并返回新对象。

• /:

   对数组中所有的元素进行相同的操作 ，foldLeft的简写。

  var a = Array(2,3,4,5)
  var b = (1/:a)(_+_)
  //运算顺序为1+2+3+4+5

  运行结果如下：

• :\

        foldRight的简写，这里从右往左进行运算。

var a = Array(2,3,4,5)
var b = (a /:1)(_-_)
//运算顺序为1-2-3-4-5
var b = (a :\1))(_-_)
//运算顺序为1-（2-（3-（4-（5-1）））））

        运行结果如下：

• addString

        将数组中的元素逐个添加到b中，并转换为字符串。

var a = List(1,1,2,4)
var b = new StringBulider()
var c = a.addString(b)
//c的内容为 1124
var c = a.addString(b)
//c的内容为 11241124

        运行结果如下： 

         其他：

    val a = List(1,2,3,4)val b = new StringBuilder()val c = a.addString(b,",") println("c:  "+c)  // c:  1,2,3,4val a = List(1,2,3,4)val b = new StringBuilder()val c = a.addString(b,"{",",","}") println("c:  "+c)  // c:  {1,2,3,4}

• aggregate

        聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

def main(args: Array[String]) {val a = List(1,2,3,4)val c = a.par.aggregate(5)(seqno,combine)println("c:"+c)}def seqno(m:Int,n:Int): Int ={val s = "seq_exp=%d+%d"println(s.format(m,n))return m+n}def combine(m:Int,n:Int): Int ={val s = "com_exp=%d+%d"println(s.format(m,n))return m+n}/**seq_exp=5+3seq_exp=5+2seq_exp=5+4seq_exp=5+1com_exp=6+7com_exp=8+9com_exp=13+17c:30*/

• apply

        取出指定索引处的元素

var b = a.apply(0)
var b = a(0)

        运行结果如下： 

• canEqual

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

• charAt

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

var c = Array('c','b','a')
var cc = c.charAt(0)

        运行结果如下：

• clone

        创建一个数组的副本

        运行结果如下

• collect

        通过执行一个并行计算（偏函数），得到一个新的数组对象

 val chars = Array('a','b','c')val newchars = chars.collect(fun)println("newchars:"+newchars.mkString(","))//我们通过下面的偏函数，把chars数组的小写a转换为大写的Aval fun:PartialFunction[Char,Char] = {case 'a' => 'A'case x => x}/**输出结果是 newchars:A,b,c */

        运行结果如下：

• collectFirst

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

//这里继续运用上一个偏函数val chars = Array('a','b','c','a')val newchars = chars.collect(fun)val fun:PartialFunction[Char,Char] = {case 'a' => 'A'case x => x}val b = chars.collectFirst(fun)

        运行结果如下

• combinations

        排列组合，这个排列组合会选出所有包含字符不一样的组合，对于 “abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组。

    val arr = Array("a","b","c")val newarr = arr.combinations(2)newarr.foreach((item) => println(item.mkString(",")))

         运行结果如下：

•  contains

        序列中是否包含指定对象

• containsSlice

        判断当前序列中是否包含另一个序列

• copyToArray

        拷贝数组中的元素

         此外，还有两种用法：    

• corresponds

        判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true 。注意，如果长度不同，始终返回false

        下面代码检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素

• count

        统计符合条件的元素个数，下面统计大于 2 的元素个数。