Scala中的Array方法

val numbers = Array(1,2,3,4)	//声明一个数组对象
val first = numbers(0)	//读取第一个元素
numbers(3) = 100	//替换第四个元素为100
val biggerNumbers = numbers.map(_*2)	//所有元素乘2

Scala提供了大量的集合操作

++[B](that: GenTraversableOnce[B]): Array[B]

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

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

++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That

这个方法同上一个方法类似，两个加号后面多了一个冒号，不同的是右边操作数的类型决定着返回结果的类型。下面代码中List和LinkedList结合，返回结果是LinkedList类型

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

+:(elem: A): Array[A]

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

    val a = List(1,2)
    val c = 0 +: a 

:+(elem: A): Array[A]

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

    val a = List(1,2)
    val c = a :+ 0

/:[B](z: B)(op: (B, T) ⇒ B): B

flodLef的简写，对数组中所有元素进行相同操作（1+2+3+4+10）

 val a = List(1,2,3,4)
 val c = (10 /: a)(_+_)

:[B](z: B)(op: (T, B) ⇒ B): B
flodRight的简写（10+1+2+3+4）

 val a = List(1,2,3,4)
 val c = (a :\ 10)(_+_)

addString(b: StringBuilder): StringBuilder
将数组的元素逐个添加到b中

    val a = List(1,2,3,4)
    val b = new StringBuilder()
    val c = a.addString(b)

将每个元素用sep分隔符分开

val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,",")

在首尾各加一个字符串，并指定sep分隔符

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

aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

  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
  }
  val a = List(1,2,3,4)
  val c = a.par.aggregate(5)(seqno,combine)

上面过程可以简写为

val c = a.par.aggregate(5)(_+_,_+_)

取数组中的最大值

 val c = a.par.aggregate(4)((x,y) => {
   println("sq:",x,y);if (x > y) x else y},(x,y) => {
   println("com",x,y);if(x>y)x else y})

apply(i: Int): T
取出指定索引出的元素

val first = a.apply(1)

canEqual(that: Any): Boolean
判断两个对象是否可以进行比较

a canEqual(b)

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

val chars = Array('a','b','c')
println("c:"+chars.charAt(0))  

clone(): Array[T]
创建一个副本

val chars = Array(‘a’,‘b’,‘c’)
val newchars = chars.clone()

collect[B](pf: PartialFunction[A, B]): Array[B]
通过执行一个并行计算（偏函数），得到一个新的数组对象
//将chars数组的小写a转换为大写A

   val chars = Array('a','b','c')
   val newchars = chars.collect(fun)
   println("newchars:"+newchars.mkString(","))
  val fun:PartialFunction[Char,Char] = {
   
    case 'a' => 'A'
    case x => x
  }

collectFirst[B](pf: PartialFunction[T, B]): Option[B]
在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

val arr = Array(1,'a',"b")
  val fun:PartialFunction[Any,Int] = {
   
    case x:Int => x*100
  }
//计算
  val value = arr.collectFirst(fun)
//另一种写法
val value = arr.collectFirst({
   case x:Int => x*100})

combinations(n: Int): collection.Iterator[Array[T]]
排列组合，这个排列组合会选出所有包含字符不一样的组合，对与"abc"、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组

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

contains[A1 >: A](elem: A1): Boolean
序列中是否包含指定对象
contains只能判断是否包含值，就算b是a的子集，也只能取b中的元素来进行判断

val a = List(1,2,3)
val b = List(1,5,6)
a contains(b)
a contains(2)

containsSlice[B](that: GenSeq[B]): Boolean
判断当前序列是否包含另一个序列

    val a = List(1,2,3,4)
    val b = List(2,3)
    a.containsSlice(b)

copyToArray(xs: Array[A]): Unit
复制数组：将数组a中的数据复制到数组b中

copyToArray(Array,start: Int,len: Int)	//start表示起始下标，len表示复制的长度
val a = Array('a', 'b', 'c')
val b : Array[Char] = new Array(5)
a.copyToArray(b)   
a.copyToArray(b,1)
a.copyToArray(b,1,2)

copyToBuffer[B >: A](dest: Buffer[B]): Unit
将数组中的内容拷贝到Buffer中
使用ArrayBuffer需要先导包：import scala.collection.mutable._

val a = Array('a', 'b', 'c')
val b:ArrayBuffer[Char