Scala基础02-数组函数总结以及案例(130个)

一、元素操作

1、+:

• 定义：def +:(elem: A): Array[A]
• 描述：在数组前面添加一个元素，并返回新的数组对象，冒号的方向指向数组

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    (12 +: a1).foreach(x=>print(x+"\t"))

2、:+

• 定义：def :+(elem: A): Array[A]
• 描述：在数组后面添加一个元素，并返回新的数组对象，冒号的方向指向数组

示例：

    var a2 = Array("a","b","c")
    a2.foreach(x=>print(x+"\t"))
    println()
    (a2 :+ 13).foreach(x=>print(x+"\t"))

3、combinations

• 定义：def combinations(n: Int): collection.Iterator[Array[T]]
• 描述：选出n个元素进行排列组合，不考虑顺序，并去重

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    a1.combinations(3).foreach(x=>println(x.mkString("-")))

4、distinct

• 定义：def distinct: Array[T]
• 描述：去除当前集合中重复的元素

示例：

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    a2.distinct.foreach(x=>print(x+"\t"))

5、drop

• 定义：def drop(n: Int): Array[T]
• 描述：删掉前n个元素，返回一个新数组

示例：
删除前n个元素

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    a2.drop(2).foreach(println)

6、dropRight

• 定义：def dropRight(n: Int): Array[T]
• 描述：删掉后n个元素，返回一个新数组

示例：
删除后n个元素

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    a1.dropRight(3).foreach(x=>print(x+"\t"))

7、dropWhile

• 定义：
• 描述：从第一个符合的元素开始删除满足条件的元素，若第一个元素就不符合条件则不做任何删除操作

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    a1.dropWhile(x=>x<3&&x>1).foreach(x=>print(x+"\t"))
    println()
    a1.dropWhile(x=>x<3&&x>=1).foreach(x=>print(x+"\t"))

8、max

• 定义：def max: A
• 描述：返回序列中最大的元素

示例：

    array2.foreach(x=>print(x+"\t"));println()
    println(array2.max)

9、min

• 定义：def min: A
• 描述：返回序列中最小的元素

示例：

    array2.foreach(x=>print(x+"\t"));println()
    println(array2.min)

10、maxBy

• 定义：def maxBy[B](f: (A) ⇒ B): A
• 描述：返回序列中符合条件的第一个元素

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.maxBy(_ > 1))

11、minBy

• 定义：def minBy[B](f: (A) ⇒ B): A
• 描述：返回序列中不符合条件的第一个元素

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.minBy(_ < 6))

12、padTo

• 定义：def padTo(len: Int, elem: A): Array[A]
• 描述：填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

示例：

    b1.foreach(x=>print(x+"\t"));println()
    b1.padTo(20,"-").foreach(x=>print(x+"\t"))
	b1.padTo(4,"-").foreach(x=>print(x+"\t"))

13、patch

• 定义：def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
• 描述：批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that；如果替换的为空集合或双引号，则为删除操作

示例：

    b1.foreach(x => print(x + "\t"));println()
    var i: Array[Int] = Array() //空集合会报错，用这种形式
    b1.patch(0, Array(12, 13, 14), 3).foreach(x => print(x + "\t"));println()
    b1.patch(2, Array(12, 13, 14), 2).foreach(x => print(x + "\t"));println()
    b1.patch(3, i, 1).foreach(x => print(x + "\t"));println()
    b1.patch(3, i, 2).foreach(x => print(x + "\t"));println()
    b1.patch(3, "", 2).foreach(x => print(x + "\t"));println()

14、permutations

• 定义：def permutations: collection.Iterator[Array[T]]
• 描述：permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合

示例：

    a1.foreach(x=>print(x+"\t"));println()
    a1.permutations.foreach(x => {
     
      println(x.mkString(":", "*", ":"))
    })

15、prefixLength

• 定义：def prefixLength(p: (T) ⇒ Boolean): Int
• 描述：由第一个索引开始，返回序列中满足条件p的元素数量，直到有不满足的则结束

示例：

    b3.foreach(x=>print(x+"\t"));println()
    println(b3.prefixLength(_ < 5))
    println(b3.prefixLength(_ > 5))

16、transform

• 定义：def transform(f: Int => Int): scala.collection.mutable.WrappedArray[Int]
• 描述：将序列中的元素转换成指定的元素（同类型），原数组会被改变

示例：

    b7.foreach(x => print(x + "\t"));println()
    b7.sorted.transform(Math.pow(_,2).toInt).foreach(x => print(x + "\t"));println()

17、update

• 定义：def update(i: Int, x: T): Unit
• 描述：将序列中 i 索引处的元素更新为 x，改变原数组，返回更改后的新数组

示例：

    b7.foreach(x => print(x + "\t"));println()
    b7.update(3,20)
    b7.foreach(x => print(x + "\t"));println()

18、updated

• 定义：def updated(index: Int, elem: A): Array[A]
• 描述：将序列中 i 索引处的元素更新为 x，不改变原数组

示例：

    b7.foreach(x => print(x + "\t"));println()
    b7.updated(3,40).foreach(x => print(x + "\t"));println()
    b7.foreach(x => print(x + "\t"));println()

二、元素取头尾

1、head

• 定义：def head: T
• 描述：返回序列的第一个元素，如果序列为空，将引发错误

示例：

b1.foreach(x=>print(x+"\t"));println()
println(b1.head)

2、headOption

• 定义：def headOption: Option[T]
• 描述：返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None

示例：

    b1.foreach(x=>print(x+"\t"));println()
    var b0:Array[Int] = Array()
    println(b1.headOption)
    println(b0.headOption)

3、last

• 定义：def last: T
• 描述：返回序列的最后一个元素，如果序列为空，将引发错误

示例：

	b1.foreach(x=>print(x+"\t"));println()
    println(b1.last)

4、lastOption

• 定义：def lastOption: Option[T]
• 描述：返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None

示例：

    b1.foreach(x=>print(x+"\t"));println()
    var b0:Array[Int] = Array()
    println(b0.lastOption)
    println(b1.lastOption)

5、tail

• 定义：def tail: Array[T]
• 描述：返回当前序列中不包含第一个元素的序列，除了头都是尾

示例：

    b1.foreach(x=>print(x+"\t"));println()
    b1.tail.foreach(x=>print(x+"\t"));println()

6、tails

• 定义：def tails: collection.Iterator[Array[T]]
• 描述：和inits类似，只不过每一步都是取尾部进行 tail 操作

示例：

    b1.foreach(x=>print(x+"\t"));println()
    b1.tails.foreach(x=>{
     x.foreach(y=>print(s"$y,"));println()})

7、init

• 定义：def init: Array[T]返回当前序列中不包含最后一个元素的序列
• 描述：返回当前序列中不包含最后一个元素的序列

示例：

    b1.foreach(x=>print(x+"\t"));println()
    b1.init.foreach(x=>print(x+"\t"));println()

8、inits

• 定义：def inits: collection.Iterator[Array[T]]
• 描述：对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象；返回一个二维数组

示例：

    b1.foreach(x=>print(x+"\t"));println()
    b1.inits.foreach(x=>{
     x.foreach(y=>print(s"$y,"));println()})

9、take

• 定义：def take(n: Int): Array[T]
• 描述：返回当前序列中，前 n 个元素组成的序列

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.take(3).foreach(x => print(x + "\t"));println()

10、takeRight

• 定义：def takeRight(n: Int): Array[T]
• 描述：返回当前序列中，从右边开始，后 n 个元素组成的序列

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.takeRight(3).foreach(x => print(x + "\t"));println()

11、takeWhile

• 定义：def takeWhile(p: (T) ⇒ Boolean): Array[T]
• 描述：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列，如果第一个值不满足，则返回空，不管后面的元素了

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.takeWhile(_>2).foreach(x => print(x + "\t"));println()
    b1.takeWhile(_%2!=0).foreach(x => print(x + "\t"));println()

三、数组中的计算

1、/:、:\

• 定义：def /:[B](z: B)(op: (B, T) ⇒ B): B ， def :[B](z: B)(op: (T, B) ⇒ B): B
• 描述：对数组中所有的元素从左向右、从右向左遍历，进行相同的迭代操作，分别为foldLeft 和foldRight 的简写

示例：

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    val add = (x:Int,y:Int)=>{
     
      var z=x+y
      println(s"$x+$y=$z")
      z
    }
    println(a2./:(0)(add))
    println(a2.:\(0)(add))

2、fold

• 定义：def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1ClassTag[U]): Array[U]
• 描述：对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同

示例：
aggregate的简化版

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    val add = (x:Int,y:Int)=>{
     
      var z=x+y
      println(s"$x+$y=$z")
      z
    }
    println(a2.fold(0)(add))

3、foldRight

• 定义：foldRight[B](z: B)(op: (B, T) ⇒ B): B
• 描述：从右到左计算

示例：

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    val add = (x:Int,y:Int)=>{
     
      var z=x+y
      println(s"$x+$y=$z")
      z
    }
    println(a2.foldRight(0)(add))

4、foldLeft

• 定义：def foldLeft[B](z: B)(op: (B, T) ⇒ B): BClassTag[U]): Array[U]
• 描述：从左到右计算

示例：

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    val add = (x:Int,y:Int)=>{
     
      var z=x+y
      println(s"$x+$y=$z")
      z
    }
    println("我是fold")
    println(a2.fold(0)(add))
    println("我是foldRight")
    println(a2.foldRight(0)(add))
    println("我是foldLeft")
    println(a2.foldLeft(0)(add))

5、product

• 定义：def product: A
• 描述：返回所有元素乘积的值

示例：

    b3.foreach(x=>print(x+"\t"));println()
    println(b3.product)

6、reduce

• 定义：def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
• 描述：对序列中的每个元素进行二元运算，不需要初始值，其他的和fold一样

示例：

    b3.foreach(x => print(x + "\t"));
    println()
    println(b3.reduce((x, y) => {
     
      var z = x + y
      println(s"$x+$y=$z")
      z
    }))

7、reduceLeft

• 定义：def reduceLeft[B >: A](op: (B, T) ⇒ B): B
• 描述：同 foldLeft，从左向右计算，不需要初始值

示例：

    b3.foreach(x => print(x + "\t"));
    println()
    println(b3.reduceLeft((x, y) => {
     
      var z = x + y
      println(s"$x+$y=$z")
      z
    }))

8、reduceRight

• 定义：def reduceRight[B >: A](op: (B, T) ⇒ B): B
• 描述：同 foldRight，从右向左计算，不需要初始值

示例：

    b3.foreach(x => print(x + "\t"));
    println()
    println(b3.reduceRight((x, y) => {
     
      var z = x + y
      println(s"$x+$y=$z")
      z
    }))

9、reduceOption

• 定义：def reduceOptionA1>:A: scala.Option[A1]
• 描述：同 reduceLeftOption，计算Option，返回 Option

示例：

    b3.foreach(x => print(x + "\t"));
    println()
    println(b3.reduceOption((x, y) => {
     
      var z = x + y
      println(s"$x+$y=$z")
      z
    }))

10、reduceLeftOption

• 定义：def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
• 描述：同 reduceLeft，返回 Option

示例：

    b3.foreach(x => print(x + "\t"));
    println()
    println(b3.reduceLeftOption((x, y) => {
     
      var z = x + y
      println(s"$x+$y=$z")
      z
    }))

11、reduceRightOption

• 定义：def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
• 描述：同 reduceRight，返回 Option

示例：

    b3.foreach(x => print(x + "\t"));
    println()
    println(b3.reduceRightOption((x, y) => {
     
      var z = x + y
      println(s"$x+$y=$z")
      z
    }))

12、scan

• 定义：def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
• 描述：同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.scan(0)(_+_).foreach(x => print(x + "\t"));println()

13、scanLeft

• 定义：def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
• 描述：同 scan，从左向右计算，每一步的计算结果放到一个新的集合中返回

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.scanLeft(0)(_+_).foreach(x => print(x + "\t"));println()

14、scanRight

• 定义：def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
• 描述：同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.scanRight(0)(_+_).foreach(x => print(x + "\t"));println()

15、sum

• 定义：def sum: A
• 描述：序列求和，元素需为 Numeric[T] 类型

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"));println()
    println(a1.sum)

四、字符串相关操作

1、addString

• 定义：def addString(b: StringBuilder): StringBuilder | def addString(b: StringBuilder, sep: String): StringBuilder | def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
• 描述：将数组中的元素逐个添加到 StringBuilder 中 | 每个元素用 sep 分隔符分开 | 在首尾各加一个字符串，并指定sep分隔符

示例：

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    var builder = new StringBuilder
    a2.addString(builder," - ")
    println(builder)
    a1.addString(builder,"[",",","]")
    println(builder)
    var builder2 = new StringBuilder
    println(a1.addString(builder2, "^"): StringBuilder)

2、mkString

• 定义：def mkString(start: String, sep: String, end: String): String
• 描述：将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

示例：

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println(a1.mkString("[", "-", "]"))
    var lst = new ArrayBuffer[Int]
    for (elem <- 1 to 5) {
     
      lst.append(Random.nextInt(100))
    }
    println(lst.mkString(")"))

3、stringPrefix

• 定义：def stringPrefix: String
• 描述：返回 toString 结果的前缀

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.stringPrefix.foreach(x=>print(x+"\t"));println()

五、方法操作

1、aggregate

• 定义：def aggregate[B](z : => B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B = { /* compiled code */ }
• 描述：aggregate是柯里化方法（将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数）， aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值

示例：
聚合

    val add = (x:Int,y:Int)=>{
     
      var z=x+y
      println(s"$x+$y=$z")
      z
    }
    var lst = new ArrayBuffer[Int]
    for (elem <- 1 to 5) {
     
      lst.append(Random.nextInt(100))
    }
    println(lst.par.aggregate(0)(add, add))

2、andThen

• 定义：override def andThen[C](k : scala.Function1[B, C]) : scala.PartialFunction[A, C] = { /* compiled code */ }
• 描述：表示方法的连续调用，相当于嵌套函数 a(b(x)(需要满足第一个函数的返回值类型为第二个函数的输入值类型)，与 compose 相反

示例：
返回的结果是个偏函数，

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println(a1.andThen(x => {
     
      if (x % 3 == 0) {
     
        "match"
      }
    })(1))
    println(a1.andThen(x => {
     
      if (x % 3 == 0) Some(x)
      else None
    })(2))

    def add(x:Int):Int=x*2
    def mul(x:Int):Int=2+x
    def rst1 = add _ andThen (mul)
    def rst2 = add _ andThen mul _
    println(rst1(3))
    println(rst2(3))

3、compose

• 定义：def compose[A](g : scala.Function1[A, T1]) : scala.Function1[A, R] = { /* compiled code */ }
• 描述：表示方法的连续调用，与 andThen 相反

示例：

    def add(x:Int):Int=x*2
    def mul(x:Int):Int=2+x
    def rst1 = add _ compose(mul)
    def rst2 = add _ compose mul _
    println(rst1(3))
    println(rst2(3))

4、applyOrElse

• 定义：def applyOrElse[A1 <: A, B1 >: B](x : A1, default : scala.Function1[A1, B1]) : B1 = { /* compiled code */ }
• 描述：如果第一个调用的参数能匹配，返回匹配的值，否则调用参数二的回调函数。

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println(a1.applyOrElse(10, {
      i: Int => 200 }))
    println(a1.applyOrElse(3, {
      i: Int => 200 }))

5、collect

• 定义：def collect[B](pf: PartialFunction[A, B]): Array[B]
• 描述：通过执行一个并行计算（偏函数），得到一个新的数组对象

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    a1.collect({
      case i if i % 2 == 0 => i }).foreach(x=>{
     print(x+"\t")})

6、collectFirst

• 定义：def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
• 描述：查找第一个符合偏函数定义的元素，并执行偏函数计算，返回值是元组

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println(a1.collectFirst({
      case i if i % 2 == 0 => i }))

7、foreach

• 定义：def foreach(f: (A) ⇒ Unit): Unit
• 描述：遍历序列中的元素，进行f的操作

示例：
其他案例的输出基本上都是foreach

    b1.foreach(x=>print(x+"\t"));println()
    b1.foreach(x=>print(s"$x,"));println()

8、iterator

• 定义：def iterator: collection.Iterator[T]
• 描述：生成当前序列的迭代器

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"));println()
    val it = a1.iterator
    while (it.hasNext) {
     
      println(it.next() * 3)
    }

9、map

• 定义：def map[B](f: (A) ⇒ B): Array[B]
• 描述：对序列中的元素进行 f 操作，返回生成的新序列，对一个维度的数据进行操作

示例：

    var a1 = Array.range(1, 5)
    a1.foreach(x => print(x + "\t"));println()
    a1.map(x=>x*2).foreach(x => print(x + "\t"));println()
    val a2 = Array(("1001", "henry", "male", 100), ("1002", "pola", "female", 130), ("1003", "ariel", "female", 200))//元组的数组
    a2.foreach(x=>print(x+"\t"));println()
    a2.map(x=>(x._3,x._4)).foreach(x=>print(x+"\t"))

10、runWith

• 定义：def runWith[U](action : scala.Function1[B, U]) : scala.Function1[A, scala.Boolean] = { /* compiled code */ }
• 描述： 执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action

示例：

    val pf4: PartialFunction[Int, Int] = (x: Int) => x match {
     
      case x if (x % 2 == 0) => x
    }
    pf4.runWith(println)(6)
    pf4.runWith(println)(5)//偏函数，不输出，因为函数里没设置
    pf4.runWith(println)(4)

    var b = Array.range(1, 20)
    b.runWith(print)(18);println()
    b.runWith(print)(21);println()
    b.runWith(print)(17);println()
    println(b.runWith(x => x match {
     
      case x if x % 2 == 0 => x
    })(17))

六、指定条件判断

1、contains

• 定义：def contains[A1 >: A](elem: A1): Boolean
• 描述：判断序列中是否包含指定对象

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println(a1.contains(5))
    println(a1.contains(3))

    var a1 = Array.range(1, 5)
    a1.foreach(x => print(x + "\t"))
    println()
    println(a1.contains(1))
    println(a1.contains(0))
    println(a1.contains("a"))

2、containsSlice

• 定义：def containsSlice[B](that: GenSeq[B]): Boolean
• 描述：判断当前序列中是否包含另一个序列(数量和顺序相等)，是否包含子序列

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println(a1.containsSlice(Array(1,2)))
    println(a1.containsSlice(Array(1,3)))

    var a1 = Array.range(1, 5)
    a1.foreach(x => print(x + "\t"))
    println()
    var a2 = Array.range(1, 4)
    a2.foreach(x => print(x + "\t"))
    println()
    var a3 = Array.range(2, 6)
    a3.foreach(x => print(x + "\t"))
    println()
    println(a1.containsSlice(a1))
    println(a1.containsSlice(a2))
    println(a1.containsSlice(a3))

3、count

• 定义：def count(p: (T) ⇒ Boolean): Int
• 描述：统计符合条件的元素个数

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println(a1.count(_ !=0))
    println(a1.count(_ > 1))
    println(a1.count(x => x > 3 && x < 9))

4、endsWith

• 定义：def endsWith[B](that: GenSeq[B]): Boolean
• 描述：判断当前序列是否以某个序列结尾

示例：

    var a1 = Array.range(1, 5)
    a1.foreach(x => print(x + "\t"))
    println()
    var a2 = Array.range(1,3)
    a2.foreach(x => print(x + "\t"))
    println()
    var a3 = Array.range(4,5)
    a3.foreach(x => print(x + "\t"))
    println()
    println(a1.endsWith(a2))
    println(a1.endsWith(a3))

5、startsWith

• 定义：def startsWith[B](that: GenSeq[B], offset: Int): Boolean
• 描述：判断序列从指定偏移处是否以某个序列开始，第二个参数是主序列的偏移量，也就是从第n位开始的位置是否以子序列结束

示例：

    var a1 = Array.range(1, 5)
    a1.foreach(x => print(x + "\t"))
    println()
    var a2 = Array.range(1,3)
    a2.foreach(x => print(x + "\t"))
    println()
    var a3 = Array.range(4,5)
    a3.foreach(x => print(x + "\t"))
    println()
    println(a1.startsWith(a2))
    println(a1.startsWith(a3))
    println(a1.startsWith(a3,3))

6、exists

• 定义：def exists(p: (T) ⇒ Boolean): Boolean
• 描述：判断当前数组是否包含符合条件的元素

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"));println()
    println(a1.exists(_ > 6))
    println(a1.exists(_ > 3))

7、filter、filterNot

• 定义：def filter(p: (T) ⇒ Boolean): Array[T]、def filterNot(p: (T) ⇒ Boolean): Array[T]
• 描述：取得当前数组中符合、不符合条件的元素，组成新的数组返回

示例：

    var a1 = Array.range(1, 5)
    a1.foreach(x => print(x + "\t"))
    println()
    a1.filter(_ % 2 == 0).foreach(x=>print(x+"\t"))
    println()
    a1.filter(x=> x % 2 == 0).foreach(x=>print(x+"\t"))
    println()
    a1.filterNot(x=> x % 2 == 0).foreach(x=>print(x+"\t"))

8、withFilter

• 定义：def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
• 描述：根据条件 p 过滤元素,不生成新的集合

示例：

    b7.foreach(x => print(x + "\t"));println()
    b7.withFilter(_>4).foreach(x => print(x + "\t"));println()

9、find

• 定义：def find(p: (T) ⇒ Boolean): Option[T]
• 描述：查找第一个符合条件的元素，返回 Option

示例：

    var a1 = Array.range(1, 5)
    a1.foreach(x => print(x + "\t"))
    println()
    println(a1.find(_ > 2))
    println(a1.find(_ > 5))

10、forall

• 定义：def forall(p: (T) ⇒ Boolean): Boolean
• 描述：检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true

示例：

	b1.foreach(x=>print(x+"\t"));println()
    println(b1.forall(_ > 0))
    println(b1.forall(_ < 0))
    println(b1.forall(_ > 2))
    println(b1.forall(_ < 10))
    println(b1.forall(_.isInstanceOf[Int]))
    println(b1.forall(_ % 2 == 0))

11、hasDefiniteSize

• 定义：def hasDefiniteSize: Boolean
• 描述：检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false，流没有确定的大小

示例：

    println(b1.hasDefiniteSize)
    println(b1.toStream)
    println(b1.toStream.hasDefiniteSize)

12、isDefinedAt

• 定义：def isDefinedAt(idx: Int): Boolean
• 描述：判断序列中是否存在指定索引

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.isDefinedAt(5))
    println(b1.isDefinedAt(7))
    println(b1.isDefinedAt(2))

13、isEmpty

• 定义：def isEmpty: Boolean
• 描述：判断序列是否为空

示例：

    a2.foreach(x=>print(x+"\t"));println()
    println(a2.isEmpty)

14、nonEmpty

• 定义：def nonEmpty: Boolean
• 描述：判断序列是否不为空

示例：

    a2.foreach(x=>print(x+"\t"));println()
    println(a2.nonEmpty)

15、isTraversableAgain

• 定义：def isTraversableAgain: Boolean
• 描述：判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写 或者说判断是否为迭代器（只能遍历一次）

示例：

    array2.foreach(x=>print(x+"\t"));println()
    println(array2.isTraversableAgain)
    println(array2.toIterator.isTraversableAgain)

七、下标索引操作

1、apply

• 定义：def apply(i: Int): T
• 描述：获取指定索引处的元素

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println(a1.apply(0))
    println(a1.apply(1))
    println(a1.apply(3))

2、charAt

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

示例：

    var a3 = Array('a','b','c','d')
    a3.foreach(x=>print(x+"\t"))
    println()
    println(a3.charAt(2))
    println(a3.charAt(3))

3、indexOf(elem)、indexOf(elem, from)

• 定义：def indexOf(elem: T): Int、def indexOf(elem: T, from: Int): Int
• 描述：返回元素 elem 在序列中第一次出现的索引，【指定从索引 from 开始查找】

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.indexOf(2))
    println(b1.indexOf(8))
    println(b1.indexOf(5))
    println(b1.indexOf(1,2))

5、indexOfSlice(that)、indexOfSlice(that, from)

• 定义：def indexOfSlice[B >: A](that: GenSeq[B]): Int、def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
• 描述：检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引，找不到返回-1；并且指定索引可以超出元素索引的范围，【指定从索引 from 开始查找，并返回第一次出现该序列】

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.indexOfSlice(Array(6,5)))
    println(b1.indexOfSlice(Array(6,7)))
    println(b1.indexOfSlice(Array(8,6)))
    println(b1.indexOfSlice(Array(8,6),2))

7、indexWhere§、indexWhere(p, from)

• 定义：def indexWhere(p: (T) ⇒ Boolean): Int、def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
• 描述：返回当前序列中第一个满足条件 p 的元素的索引【，指定从索引 from 开始查找】

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.indexWhere(_==6))
    println(b1.indexWhere(_>2))
    println(b1.indexWhere(_==6,3))
    println(b1.indexWhere(_>2,3))

9、lastIndexOf(elem: T)、lastIndexOf(elem: T, end: Int)

• 定义：def lastIndexOf(elem: T): Int、def lastIndexOf(elem: T, end: Int): Int
• 描述：返回元素 elem 在序列中最后一次出现的索引【，指定在索引 end 之前（包括）的元素中查找】

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.lastIndexOf(2))
    println(b1.lastIndexOf(8))
    println(b1.lastIndexOf(5))
    println(b1.lastIndexOf(1,2))

11、lastIndexOfSlice(that)、lastIndexOfSlice(that, end)

• 定义：def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
• 描述：检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引【，指定在索引 end 之前（包括）的元素中查找】

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.lastIndexOfSlice(Array(6,7)))
    println(b1.lastIndexOfSlice(Array(8,6)))
    println(b1.lastIndexOfSlice(Array(8,6),2))

14、lastIndexWhere§、lastIndexWhere(p, end)

• 定义：def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
• 描述：返回当前序列中最后一个满足条件 p 的元素的索引，指定在索引 end 之前（包括）的元素中查找

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.lastIndexWhere(_==6))
    println(b1.lastIndexWhere(_>2))
    println(b1.lastIndexWhere(_==6,3))
    println(b1.lastIndexWhere(_>2,3))

15、indices

• 定义：def indices: collection.immutable.Range
• 描述：返回当前序列索引集合

示例：

    b1.foreach(x=>print(x+"\t"));println()
    println(b1.indices)
    b1.indices.foreach(x=>print(x+"\t"));println()

16、slice

• 定义：def slice(from: Int, until: Int): Array[T]
• 描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.slice(2,4).foreach(x => print(x + "\t"));println()

17、subSequence

• 定义：def subSequence(start: Int, end: Int): CharSequence
• 描述：返回 start 和 end 间的字符序列，不包含 end 处的元素，(返回 start 和 end 间的字符序列 只针对char类型(前包后不包))

示例：

    b5.foreach(x => print(x + "\t"));println()
    println(b5.subSequence(1, 3))

18、view

• 定义：def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
• 描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素。对于数组的操作有点像slice，前包后不包

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.view(2,4).foreach(x => print(x + "\t"));println()
    println(b1.view(2, 4))

八、数组拆分排序

1、groupBy

• 定义：def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
• 描述：按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组

示例：

    var add2 = (x: Int, y: Int) => {
     
      val z = x + y
      println(s"$x + $y = $z")
      z
    }
    var array2 = Array(1, 2, 3, 5, 7)
    println(array2.groupBy(x => x match {
     
      case i if i % 2 == 0 => "even"
      case i => "odd"
    }).map(x => (x._1, x._2.par.fold(0)(add2))))

2、grouped

• 定义：def grouped(size: Int): collection.Iterator[Array[T]]
• 描述：按指定数量分组，每组有 size 个元素，返回一个迭代器

示例：

    var array2 = Array(1, 2, 3, 5, 7)
    array2.grouped(2).foreach(x=>{
     
      x.foreach(y=>print(y+"\t"))
      println()
    })

    var array2 = Array(1, 2, 3, 5, 7)
    println(array2.grouped(2).map(x => x.fold(0)(add2)).fold(0)(add2))

3、par

• 定义：def par: ParArray[T]
• 描述：返回一个并行实现，产生的并行序列不能被修改，其作用相当于hashcode进行分区

示例：

    var lst = new ArrayBuffer[Int]
    for (elem <- 1 to 5) {
     
      lst.append(Random.nextInt(100))
    }
    lst.foreach(x=>print(x+"\t"))
    println()
    println(lst.par)

4、partition

• 定义：def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
• 描述：按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

示例：

    b1.foreach(x=>print(x+"\t"));println()
    b1.partition(_>5)._2.foreach(x=>print(x+"\t"))
    println()
    b1.partition(_>5)._1.foreach(x=>print(x+"\t"))
    println()

5、span

• 定义：def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
• 描述：将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

示例：

    a3.foreach(x => print(x + "\t"));println()
    a3.span(_ <= 2)._1.foreach(x => print(x + "\t"));println()
    a3.span(_ <= 2)._2.foreach(x => print(x + "\t"));println()

6、splitAt

• 定义：def splitAt(n: Int): (Array[T], Array[T])
• 描述：从指定位置开始，把序列拆分成两个数组，指定索引位置元素放入第二个数组中

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.splitAt(3)._1.foreach(x => print(x + "\t"));println()
    b1.splitAt(3)._2.foreach(x => print(x + "\t"));println()

7、sliding(size)、sliding(size, step)

• 定义：def sliding(size: Int): collection.Iterator[Array[T]]、def sliding(size: Int): collection.Iterator[Array[T]]
• 描述：滑动，从第一个元素开始，每个元素和它后面的 size个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够size时，则结束。【该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始】
• 如果size=step，则等同于grouped(5)

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.sliding(2).foreach(x =>{
     x.foreach(y=>print(y+"\t"));println()});println()
    println()
    b1.sliding(2,2).foreach(x =>{
     x.foreach(y=>print(y+"\t"));println()});println()
    println()
    b1.sliding(3).foreach(x =>{
     x.foreach(y=>print(y+"\t"));println()});println()
    println()
    b1.sliding(3,2).foreach(x =>{
     x.foreach(y=>print(y+"\t"));println()});println()

8、sortBy

• 定义：def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
• 描述：按指定的排序规则对序列排序

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.sortBy(x=>x).foreach(x => print(x + "\t"));println()
    b1.sortBy(x=>(-x)).foreach(x => print(x + "\t"));println()

9、sorted

• 定义：def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]]
• 描述：使用默认的排序规则对序列排序，默认升序排列，无参数

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.sorted.foreach(x => print(x + "\t"));println()

10、sortWith

• 定义：def sortWith(t:(T,T)=>boolean)：Array[T]
• 描述：自定义排序方法

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.sortWith(_>_).foreach(x => print(x + "\t"));println()
    b1.sortWith(_<_).foreach(x => print(x + "\t"));println()

九、数组长度

1、length

• 定义：def length: Int
• 描述：返回序列元素个数

示例：

    array2.foreach(x=>print(x+"\t"));println()
    println(array2.length)
    println(array2.size)

2、lengthCompare

• 定义：def lengthCompare(len: Int): Int
• 描述：比较序列的长度和参数 len，返回序列的长度减去参数len,根据二者的关系返回不同的值，长度length更小的话则为负，比较规则是：
  x>0, length > len
  x=0, length = len
  x<0, length < len

示例：

    array2.foreach(x=>print(x+"\t"));println()
    println(array2.length)
    println(array2.lengthCompare(5))
    println(array2.lengthCompare(3))
    println(array2.lengthCompare(7))

3、segmentLength

• 定义：def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
• 描述：从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个，第一个不满足的话就结束

示例：

    b1.foreach(x => print(x + "\t"));println()
    println(b1.segmentLength(_ > 4, 0))
    println(b1.segmentLength(_ > 4, 1))
    println(b1.segmentLength(_ > 4, 2))

4、size

• 定义：def size: Int
• 描述：返回序列元素个数，同 length

示例：

    array2.foreach(x=>print(x+"\t"));println()
    println(array2.length)
    println(array2.size)

十、两数组操作

1、++

• 定义：def ++[B](that: GenTraversableOnce[B]): Array[B]
• 描述：合并两个集合，新数组包含左右两个集合的内容，如果两个数组类型不同，合同之后的类型为Array[Any]，类似Java里的Object类型

示例：

    var a1=Array.range(1,5)
    var a2 = Array("a","b","c")
    a1.foreach(x=>print(x+"\t"))
    println()
    a2.foreach(x=>print(x+"\t"))
    println()
    println("----++---------------")
    //++合并
    (a1++a2).foreach(x=>print(x+"\t"))

2、++:

• 定义：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
• 描述：也是两个数组组合起来，冒号旁边的类型决定生成新数组的数据类型

示例：

    var a1=Array.range(1,5)
    var a2 = Array(1.0,1,2)
    a1.foreach(x=>print(x+"\t"))
    println()
    a2.foreach(x=>print(x+"\t"))
    println()
    (a1++:a2).foreach(x=>print(x+"\t"))//x为double类型

3、canEqual

• 定义：def canEqual(that: Any): Boolean
• 描述：判断两个对象数组是否可以进行比较，基本上都可以比较，应该不常用

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    var a2 = Array("a","b","c")
    a2.foreach(x=>print(x+"\t"))
    println()
    println(a2.canEqual(a1))

4、union

• 定义：def union(that: collection.Seq[T]): Array[T]
• 描述：合并两个序列，同操作符 ++

示例：

    var a1=Array.range(1,5)
    var a2=Array.range(8,12)
    a1.foreach(x=>print(x+"\t"));println()
    a2.foreach(x=>print(x+"\t"));println()
    a1.union(a2).foreach(x=>print(x+"\t"));println()
    (a1 union a2).foreach(x=>print(x+"\t"));println()

5、corresponds

• 定义：def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
• 描述：判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(x, y)=true，则返回 true,不满足返回false

示例：

    var a1=Array.range(1,5)
    var a2=Array.range(8,12)
    a1.foreach(x=>print(x+"\t"));println()
    a2.foreach(x=>print(x+"\t"));println()
    println(a1.corresponds(a2)((x, y) => x + 7 == y))
    println(a1.corresponds(a2)((y, x) => x + 7 == y))

6、diff

• 定义：def diff(that: collection.Seq[T]): Array[T]
• 描述：计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回

示例：

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println("-----diff--------")
    //取差集
    a1.diff(a2).foreach(println)
    println("-----intersect--------")
    //取交集
    a1.intersect(a2).foreach(println)

7、intersect

• 定义：def intersect(that: collection.Seq[T]): Array[T]
• 描述：返回两个集合的交集

示例：

    var a2 = Array(1,1,2)
    a2.foreach(x=>print(x+"\t"))
    println()
    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    println("-----diff--------")
    //取差集
    a1.diff(a2).foreach(println)
    println("-----intersect--------")
    //取交集
    a1.intersect(a2).foreach(println)

8、sameElements

• 定义：def sameElements(that: GenIterable[A]): Boolean
• 描述：判断两个序列是否顺序和对应位置上的元素都一样，值比较

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    var a3 = a1.clone()
    println(a1 == a3)
    //重写same方法，比较值
    def same(a1:Array[Int],a2:Array[Int]):Boolean={
     
      var same:Boolean=true
      if (a1.size!=a2.size) {
     
        same = false
      }else{
     
        breakable{
     
          for (elem <- 0 until a1.size) {
     
            if (a1(elem)!=a2(elem)) {
     
              same=false
              break()
            }

          }
        }
      }
      same
    }
    println(same(a1, a3))
    println(a1.sameElements(a3))

十一、数组克隆和复制

1、clone

• 定义：def clone(): Array[T]
• 描述：创建一个数组的副本，复制数组的值,但不会引用地址；就是说是浅克隆，不是深克隆。

示例：

    var a1=Array.range(1,5)
    a1.foreach(x=>print(x+"\t"))
    println()
    var a3 = a1.clone()
    println(a1 == a3)
    println(a1.sameElements(a3))

2、copyToArray

• 定义：def copyToArray(xs: Array[A]): Unit | def copyToArray(xs: Array[A], start: Int): Unit | def copyToArray(xs: Array[A], start: Int, len: Int): Unit
• 描述：将当前数组元素复制到另一个数组中，2-3的参数是待复制的数组的起始位置和长度

示例：

    var lst2= new ArrayBuffer[Int]
    for (elem <- 1 to 6) {
     
      lst2.append(Random.nextInt(100))
    }
    var arr1 = Array(0,0,0,0)
    var arr2 = Array(0,0,0,0)
    var arr3 = Array(0,0,0,0)
    var arr4 = Array(0,0,0,0)
    lst2.foreach(x=>print(x+"\t"))
    println()
    lst2.copyToArray(arr1)
    lst2.copyToArray(arr2,2)
    lst2.copyToArray(arr3,0,2)
    lst2.copyToArray(arr4,1,2)
    arr1.foreach(x=>print(x+"\t"))
    println()
    arr2.foreach(x=>print(x+"\t"))
    println()
    arr3.foreach(x=>print(x+"\t"))
    println()
    arr4.foreach(x=>print(x+"\t"))

3、copyToBuffer

• 定义：def copyToBuffer[B >: A](dest: Buffer[B]): Unit
• 描述：将数组中的元素复制到 Buffer 中

示例：

    var lst2= new ArrayBuffer[Int]
    for (elem <- 1 to 6) {
     
      lst2.append(Random.nextInt(100))
    }
    lst2.foreach(x=>print(x+"\t"))
    println()
    var buff = new ArrayBuffer[Int]
    println(buff.size)
    lst2.copyToBuffer(buff)
    println(buff.size)
    buff.foreach(x=>print(x+"\t"))

4、seq

• 定义：def seq: collection.mutable.IndexedSeq[T]
• 描述：产生一个引用当前序列的 sequential 视图，就是一个特殊的集合，WrappedArray

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.seq.foreach(x => print(x + "\t"));println()
    println(b1.seq)

十二、数组反转

1、reverse

• 定义：def reverse: Array[T]
• 描述：反转序列

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.reverse.foreach(x => print(x + "\t"));println()

2、reverseIterator

• 定义：def reverseIterator: collection.Iterator[T]
• 描述：生成反向迭代器

示例：

    b1.foreach(x => print(x + "\t"));println()
    println(b1.isTraversableAgain)
    b1.reverseIterator.foreach(x => print(x + "\t"));println()
    println(b1.reverseIterator.isTraversableAgain)

3、reverseMap

• 定义：def reverseMap[B](f: (A) ⇒ B): Array[B]
• 描述：同 map，方向相反

示例：

    b1.foreach(x => print(x + "\t"));println()
    b1.map(x=>print(x + "\t"));println()
    b1.reverseMap(x=>print(x + "\t"));println()

十三、数组的行列操作

1、flatMap

• 定义：def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
• 描述：先map后降维，对当前序列的每个元素进行操作，map之后的每个元素必须还是集合，结果放入新序列返回，参数要求是 GenTraversableOnce 及其子类。什么类型调用的flatMap方法，则返回的也是什么类型

示例：

    val a2 = Array(Array(1,3,5),Array(2,4,6))
    a2.flatMap(x=>x.map(x=>(x,1))).foreach(x=>print(x+"\t"))
    println()
    a2.flatMap(x=>x.map(x=>(if(x%2==0) "even" else "odd",1))).foreach(x=>print(x+"\t"))
    println()

2、flatten

• 定义：def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
• 描述：扁平化(降维)，将二维数组的所有元素组合在一起，形成一个一维数组返回

示例：

    val a2 = Array(Array(1,3,5),Array(2,4,6),Array(7,8,9))
    a2.foreach(x => {
     
      x.foreach(y=>print(y + "\t"))
      println()
    })
    a2.flatten.foreach(x => print(x + "\t"))

3、transpose

• 定义：def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
• 描述：矩阵转置，二维数组行列转换

示例：

    var b9=Array(Array(1,2,3),Array(4,5,6),Array(7,8,9),Array(11,12,13),Array(21,22,3))
    b9.foreach(x =>{
     x.foreach(y=>print(y+"\t"));println()});println()
    println()
    b9.transpose.foreach(x =>{
     x.foreach(y=>print(y+"\t"));println()});println()

4、unzip

• 定义：def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
• 描述：将二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组

示例：

    var b10=Array(("henry",19),("aaaa",12))
    b10.unzip._1.foreach(x => print(x + "\t"));println()
    b10.unzip._2.foreach(x => print(x + "\t"));println()

5、unzip3

• 定义：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 b11=Array(("henry",19,4),("aaaa",12,4))
    b11.unzip3._1.foreach(x => print(x + "\t"));println()
    b11.unzip3._2.foreach(x => print(x + "\t"));println()
    b11.unzip3._3.foreach(x => print(x + "\t"));println()

6、zip

• 定义：def zip[B](that: GenIterable[B]): Array[(A, B)]
• 描述：将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同

示例：

    var c1=Array(1,2,3)
    var c2=Array("a","b","c")
    c1.zip(c2).foreach(x=>print(x+"\t"));println()

7、zipAll

• 定义：def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
• 描述：同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem

示例：

    var c3=Array(1,2,3)
    var c4=Array("a","b","c","d")
    c4.zipAll(c3,0,"z").foreach(x=>print(x+"\t"));println()
    c3.zipAll(c4,0,"z").foreach(x=>print(x+"\t"));println()

8、zipWithIndex

定义：def zipWithIndex: Array[(A, Int)]
描述：序列中的每个元素和它的索引组成一个元组数组

示例：

    var c5=Array("a","b","c","d")
    c5.zipWithIndex.foreach(x=>print(x+"\t"));println()

十四、类型转换

1、toArray

• 定义：def toArray: Array[A]
• 描述：将序列转换成 Array 类型

示例：

2、toBuffer

• 定义：def toBuffer[A1 >: A]: Buffer[A1]
• 描述：将序列转换成 Buffer 类型

示例：

3、toIndexedSeq

• 定义：def toIndexedSeq: collection.immutable.IndexedSeq[T]
• 描述：将序列转换成 IndexedSeq 类型

示例：

4、toIterable

• 定义：def toIterable: collection.Iterable[T]
• 描述：将序列转换成可迭代的类型

示例：

5、toIterator

• 定义：def toIterator: collection.Iterator[T]
• 描述：将序列转换成迭代器，同 iterator 方法

示例：

6、toList

• 定义：def toList: List[T]
• 描述：将序列转换成 List 类型

示例：

7、toMap

• 定义：def toMap[T, U]: Map[T, U]
• 描述：将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型，Tuple2 类型意思是：元组必须是2元的，以元组的第一个元素做键，第二个元素做值

示例：

    val b8 = Array((1,"a"),(3,"c"),(4,"d"))
    b8.foreach(x=>print(x+"\t"));println()
    println(b8.toMap)

8、toSeq

• 定义：def toSeq: collection.Seq[T]
• 描述：转换成序列

示例：

9、toSet

• 定义：def toSet[B >: A]: Set[B]
• 描述：将序列转换成 Set 类型

示例：

    var b7=Array(2,1,4,3,5,2,1)
    b7.foreach(x => print(x + "\t"));println()
    println(b7.toSet)

10、toStream

• 定义：def toStream: collection.immutable.Stream[T]
• 描述：将序列转换成 Stream 类型（流类型），懒de序列，只存一个值，其他值需要时再取

示例：

    b7.foreach(x => print(x + "\t"));println()
    println(b7.toStream)
    println(b7.toStream.head)
    println(b7.toStream.tail)
    println(b7.inits.toStream)

11、toVector

• 定义：def toVector: Vector[T]
• 描述：将序列转换成 Vector 类型，内部线程安全，但效率低

示例：