＜Zhuuu_ZZ＞Scala(二)数组方法大全---最详细

数组的三种创建方式

object demoArray {
  def main(args: Array[String]): Unit = {
    //数组创建方式一
    var array:Array[String]=new Array[String](3)
    array(0)="hello"
    array(1)="world"
    array(2)="scala"
    println(array(0))
    //数组创建方式二：调用Array的伴生对象中的apply()返回Array实例
    var array2=Array("kb09","luoxing","gree","ruiwen")
    println(array2(3))
    //数组创建方式三：区间数组，左闭右开
    var array3=Array.range(1,10,3)//从1到10每次加3储存
    for(i<-array3){
      print(i+"-")   //输出结果为：1-4-7-
    }
  }
}

ArrayMethods

++

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

    val a=Array(1,2)
    val b=Array(3,4)
    val c=a++b
//c中的内容是(1,2,3,4)

++:

合并集合并右边操纵数的类型决定着返回结果的类型

    val a = List(1,2)
    val b = scala.collection.mutable.LinkedList(3,4)
    val c = a ++: b  //scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)
    println(c.getClass().getName())// c的类型是：scala.collection.mutable.LinkedList

+:

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

    val a = List(1,2)
    val c = 0 +: a // c中的内容是 （0,1,2）

:+

    val a=List(1,2)
    val b=a:+0  //b中的内容是(1,2,0)

/:

对数组中所有的元素进行相同的操作，等同于foldLeft

    val a = List(1,2,3,4)
    val c = (10 /: a)(_+_)   // 10+1+2+3+4
    val d = (10 /: a)(_*_)   // 10*1*2*3*4
    println("c:"+c)   // c:20
    println("d:"+d)   // d:240

:\

等同于foldRight

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

addString

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

    val a = List(1,2,3,4)
    val b = new StringBuilder()
    val c = a.addString(b)   // c中的内容是  1234
    val c = a.addString(b,",") //c中的内容是 12341,2,3,4
    val c = a.addString(b,"{",",","}") //c中的内容是 12341,2,3,4{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+3
    seq_exp=5+2
    seq_exp=5+4
    seq_exp=5+1
    com_exp=6+7
    com_exp=8+9
    com_exp=13+17
    c:30
  */

等价于

val c = a.par.aggregate(5)(_+_,_+_)
//5*a内元素数量+a内元素之和

apply(i:Int):T

获取数组内某个元素

val numbers=Array(1,2,3,4)
val first=numbers(1) //读取第二个元素  
val first=numbers.apply(1) //上下等价

canEqual(that:Any):Boolean

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

val a="haha"
val b=1
val c=a canEqual b
//c: Boolean = true

charAt(index:Int):Char

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

val chars=Array('a','b','c')
println("c:"+chars.charAt(0))  //结果为c:a
val chars=Array("a","b","c")   
println("c:"+chars.charAt(0))  //error: value charAt is not a member of Array[String]

clone():Array[T]

创建一个副本

val chars=Array('a','b','c')
val newchars=chars.clone()  //创建一个新对象
println({if(chars.eq(newchars)) 1 else 0})  //0

collect()

一般跟偏函数联用

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

collectFirst()

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

val arr = Array(1,'a',"b")//当数组内元素各不相同自动转化为Any类型，
//定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作，对于上面定义的对象arr来说，只有第一个元素符合要求
  val fun:PartialFunction[Any,Int] = {
    case x:Int => x*100
  }
//计算
  val value = arr.collectFirst(fun)
  println("value:"+value.mkString)
//另一种写法
val value = arr.collectFirst({case x:Int => x*100})

combinations(n: Int): collection.Iterator[Array[T]]

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

val chars=Array('a','b','c','d','e')
val newchars=chars.combinations(3)   // Iterator[Array[Char]] = non-empty iterator
newchars.foreach(x=>println(x.mkString))  //迭代器打印必须.mkString
//for(x<-newchars)println(x.mkString)

contains()

序列中是否包含指定对象

val a=List(1,2,3,4)
val b=2
println(a.contains(b))  //true

containsSlice()

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

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

copyToArray()

此方法还有两个类似的方法
copyToArray(xs: Array[A], start: Int): Unit
copyToArray(xs: Array[A], start: Int, len: Int): Unit

val a = Array('a', 'b', 'c')
val b : Array[Char] = new Array(5)
a.copyToArray(b)    /**b中元素 ['a','b','c',?,?]*/
a.copyToArray(b,1)  /**b中元素 [0,'a','b','c',0]*/  //从b的下标为1的地方复制a
a.copyToArray(b,1,2)    /**b中元素 [0,'a','b',0,0]*/ //从b的下标为1的地方复制a的长度为2

copyToBuffer()

将数组中的内容拷贝到Buffer中
默认不可变集合，所以copyToBuffer需要导包 import scala.collection.mutable._

val a=Array('a','b','c')
val b:ArrayBuffer[Char]=ArrayBuffer()
a.copyToBuffer(b)
b.append('d')                  //scala.collection.mutable.ArrayBuffer[Char] = ArrayBuffer(a, b, c, d)

corresponds()

判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true
下面代码检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素

val a = Array(1, 2, 3)
val b = Array(4, 5,6)
println(a.corresponds(b)(_<_))  //true

diff()

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

val a = Array(1, 2, 3,4)
val b = Array(4, 5,6,7)
val c = a.diff(b)
println(c.mkString) //1,2,3

diff于对象的使用

class Person(uname:String,uage:Int){
  val name:String=uname
  val age:Int=uage
 ..............................
  override def toString: String = name+age //重写toString方法使下方可以正常打印，否则只能打印地址
  override def equals(obj: scala.Any): Boolean =if(obj==name)true else false  //重写equals方法,比较两个对象，只要名字相同就是同一个对象
}
object Person{
  ............................
  def main(args:Array[String]):Unit={
    val p1=new Person("zs",21)
    val p2=new Person("ls",22)
    val p3=new Person("ww",23)
    val p4=new Person("ww",23)
    if(p3.equals(p4)) println(true) else println(false)  //true  //如果没有上面重写equals方法就是false，因为比较的是地址。
    if(p3.eq(p4)) println(true) else println(false)  //true 这里就算我们在上面重写了equals方法也无效，因eq比较的是地址，本来就是两个不同对象也就是两个不同地址。
    if(p3==p4) println(true) else println(false)  //true 比较的对象是null那么==调用的是eq，不是null的情况调用的是equals。而因为上方重写equals方法所以为true，否则为false。
    val personArr=Array(p1,p2,p4)
    val personArr2=Array(p2,p3)
    val persons = personArr.diff(personArr2)  //比较的是地址  
    persons.foreach(println)  //打印 zs21
                                     ww23
 }
}

count(p: (T) ⇒ Boolean): Int

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

    val a = Array(1, 2, 3)
    println(a.count({x:Int => x > 2}))  // count = 1

distinct

去除当前集合中重复的元素，只保留一个

val a = Array(1, 2, 3,4,4,5,6,6)
val c = a.distinct
println(c.mkString(","))    // 1,2,3,4,5,6

drop(n: Int): Array[T]

将当前序列中前 n 个元素去除后，作为一个新序列返回

val a = Array(1, 2, 3,4)
val c = a.drop(2)
println(c.mkString(","))    // 3,4

dropRight(n: Int): Array[T]

去掉尾部的n个元素

val a = Array(1, 2, 3,4)
val c = a.dropRight(2)
println(c.mkString(","))    // 1,2

dropWhile(p: (T) ⇒ Boolean): Array[T]

去除当前数组中符合条件的元素返回留下的元素成为一个新数组，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

//下面去除大于2的，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 2,3,4
val a = Array(3, 2, 3,4)
val c = a.dropWhile( {x:Int => x > 2} )
println(c.mkString(","))
 
//如果数组 a 是下面这样，第一个元素就不满足，所以返回整个数组 1, 2, 3,4
val a = Array(1, 2, 3,4) 

endsWith[B](that: GenSeq[B]): Boolean

• 判断是否以某个序列结尾

val a = Array(3, 2, 3,4)
val b = Array(3,4)
println(a.endsWith(b))  //true

exists(p: (T) ⇒ Boolean): Boolean

判断当前数组是否包含符合条件的元素

val a=Array(1,2,3,4)
a.exists(_==3)  //true
a.exists(x=>{println(x);x>2})  //1 2 3  Boolean=true   找到第一个符合条件的退出，找不到就全部打印
a.exists(x=>{println(x);x>0})  //1      Boolean=true
a.exists(x=>{println(x);x>4})  //1 2 3 4 Boolean=false

filter(p: (T) ⇒ Boolean): Array[T]

取得当前数组中符合条件的元素，组成新的数组返回

val a=Array(1,2,3,4)
val b=a.filter({x:Int => x>2})
println(b.mkString(","))  //3,4

filterNot(p: (T) ⇒ Boolean): Array[T]

与上面的 filter 作用相反

val a = Array(3, 2, 3,4)
val b = a.filterNot( {x:Int => x> 2} )
println(b.mkString(","))    //2

find(p: (T) ⇒ Boolean): Option[T]

查找第一个符合条件的元素

val a = Array(1, 2, 3,4)
val b = a.find( {x:Int => x>2} )
println(b.mkStirng)  // 3

flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]

对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类

val a=Array(1,2,3,4)
a.flatMap(x=> 1 to x)  //c: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)
a.flatMap(1 to _)  //与上方等价，那就说明了_代表了当只有一个参数时，=>右边的x可以用_代替，左边x和=>可省略
 val str=Array("hello world","hello java")
str.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).map(x=>(x._1,x._2.size)).toList.sortBy(-_._2)

通过sortBy或者aggregate求数组最大值

val a=Array(1,2,4,8,3,9,6)
//先排序再求最大值
val b=a.toList.sortBy(-_).apply(0)  
//通过aggregate
val c=a.par.aggregate(0)((x:Int,y:Int)=>{println("seq",x,y);if(x>y) x else y},(x,y)=>{println("combine",x,y);if(x>y) x else y}) 
/*
(seq,0,1)
(seq,0,9)
(seq,0,8)
(seq,0,3)
(seq,0,2)
(seq,0,4)
(combine,8,3)
(seq,0,6)
(combine,2,4)
(combine,9,6)
(combine,1,4)
(combine,8,9)
(combine,4,9)
c: Int = 9

flatten

将二维数组的所有元素联合在一起，形成一个一维数组返回

val dArr = Array(Array(1,2,3),Array(4,5,6))
val c = dArr.flatten
println(c.mkString(","))    //1,2,3,4,5,6

fold()

对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的执行过程。
因为aggregate需要两个处理方法，所以我们定义一个combine方法

  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 = Array(1, 2, 3,4)
    val b = a.fold(5)(seqno)  //实际上就是传入值5+序列中元素之和
    /** 运算过程
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4
    */
    val c = a.par.aggregate(5)(seqno,combine)  //实际上就是传入值5*序列中元素数量+序列中元素之和
    /** 运算过程
    seq_exp=5+1
    seq_exp=5+4
    seq_exp=5+3
    com_exp=8+9
    seq_exp=5+2
    com_exp=6+7
    com_exp=13+17
    */

foldLeft()

等同于/:
从左到右计算

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldLeft(5)(seqno)
    /** 运算过程
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4
    */
    /**
    简写 (5 /: a)(_+_)
    */

foldRight

等同于 :\
从右到左计算

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldRight(5)(seqno)
    /** 运算过程
    seq_exp=4+5
    seq_exp=3+9
    seq_exp=2+12
    seq_exp=1+14
    */
    /**
    简写 (a :\ 5)(_+_)
    */

forall(p: (T) ⇒ Boolean): Boolean

如果序列中的元素都满足条件 p返回true

    val a = Array(1, 2, 3,4)
    val b = a.forall( {x:Int => x>0})   //true
    val b = a.forall( {x:Int => x>2})   //false

foreach(f: (A) ⇒ Unit): Unit

遍历序列中的元素，进行 f 操作

val a = Array(1, 2, 3,4，5，6)
a.foreach(x => println(x*10))
/*
10
20
30
40
50
60
 */
scala> a.foreach(println)
/*
1
2
3
4
5
6
*/
scala> a.foreach(x=>println(x>2))
/*
false
false
true
true
true
true
*/

groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]

按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列。

val a=Array(1,2,3,4)
a.groupBy(x=>x>2)
//结果：scala.collection.immutable.Map[Boolean,Array[Int]] = Map(false -> Array(1, 2), true -> Array(3, 4))

val a=Array(1,2,4,8,3,9,6)
 val b=a.groupBy(x=> x match{
 case x if(x<3) =>"small"
 case x if(x==3) =>"middle"
 case _ =>"big"
 }
 )
//scala.collection.immutable.Map[String,Array[Int]] = Map(small -> Array(1, 2), big -> Array(4, 8, 9, 6), middle -> Array(3))

val arr=Array("hello scala","hello python","hello spark","happy study","happy love")
arr.groupBy(x=>x.split(" ")(0))
//res8: scala.collection.immutable.Map[String,Array[String]] = Map(happy -> Array(happy study, happy love), hello -> Array(hello scala, hello python, hello spark))
arr.groupBy(x=>x.split(" ")(1))
//res9: scala.collection.immutable.Map[String,Array[String]] = Map(spark -> Array(hello spark), love -> Array(happy love), scala -> Array(hello scala), python -> Array(hello python), study -> Array(happy study))

grouped(size: Int): collection.Iterator[Array[T]]*

按指定数量分组，每组有 size 数量个元素，返回一个集合

val a = Array(1, 2, 3,4,5)
val b = a.grouped(3).toList
b.foreach((x) => println("第"+(b.indexOf(x)+1)+"组:"+x.mkString(",")))
/**
第1组:1,2,3
第2组:4,5
*/

hasDefiniteSize: Boolean

检测序列是否存在有限的长度，对应Stream这样的流数据，返回false
或者如果迭代器为空，则返回true，否则返回false

val a = Array(1, 2, 3,4,5)
println(a.hasDefiniteSize)  //true
val b=a.toStream           //scala.collection.immutable.Stream[Int] = Stream(1, ?)
println(b.hasDefiniteSize)  //false

//迭代器
val a=Array(1,2,3,4,5,6)
scala> a.grouped(2)
//res0: Iterator[Array[Int]] = non-empty iterator
scala> a.grouped(2).hasDefiniteSize
//res1: Boolean = false
scala> val iter=Iterator()
//iter: Iterator[Nothing] = empty iterator
scala> iter.hasDefiniteSize
//res2: Boolean = true

head: T

返回序列的第一个元素，如果序列为空，将引发错误

val a = Array(1, 2, 3,4,5)
println(a.head) //1
val a:Array[Int]=Array()  //a: Array[Int] = Array()
a.head
//java.util.NoSuchElementException: next on empty iterator
  at scala.collection.Iterator$$anon$2.next(Iterator.scala:39)
  at scala.collection.Iterator$$anon$2.next(Iterator.scala:37)
  at scala.collection.IndexedSeqLike$Elements.next(IndexedSeqLike.scala:63)
  at scala.collection.IterableLike$class.head(IterableLike.scala:107)
  at scala.collection.mutable.ArrayOps$ofInt.scala$collection$IndexedSeqOptimized$$super$head(ArrayOps.scala:234
  at scala.collection.IndexedSeqOptimized$class.head(IndexedSeqOptimized.scala:126)
  at scala.collection.mutable.ArrayOps$ofInt.head(ArrayOps.scala:234)
  ... 32 elided

headOption: Option[T]

返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None

val a = Array(1, 2, 3,4,5)
val b:Array[Int] = Array()
println(a.headOption)   //Some(1)
println(b.headOption)   //None

indexOf(elem: T): Int

返回elem在序列中的索引，找到第一个就返回

val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3))   // return 1

indexOf(elem:T,from:Int)

val a=Array(1,2,3,4,5,6)
scala> a.indexOf(2,3)
//res6: Int = -1    //找不到则返回-1
scala> a.indexOf(5,3)
//res8: Int = 4     //找到返回elem在a中的索引

indexOfSlice[B >: A](that: GenSeq[B]): Int

检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引

    val a = Array(1, 3, 2, 3, 4)
    val b = Array(2,3)
    println(a.indexOfSlice(b))  // return 2

indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int

检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始

    val a = Array(1, 3, 2, 3, 2, 3, 4)
    val b = Array(2,3)
    println(a.indexOfSlice(b,3))    // return 4

indexWhere(p: (T) ⇒ Boolean): Int

返回当前序列中第一个满足 p 条件的元素的索引

    val a = Array(1, 2, 3, 4)
    println(a.indexWhere( {x:Int => x>3}))  // return 3

indexWhere(p: (T) ⇒ Boolean, from: Int): Int
返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始

    val a = Array(1, 2, 3, 4, 5, 6)
    println(a.indexWhere( {x:Int => x>3},4))    // return 4

indices

返回当前序列索引集合

    val a = Array(10, 2, 3, 40, 5)
    val b = a.indices
    println(b.mkString(","))    // 0,1,2,3,4

init: Array[T]

返回当前序列中不包含最后一个元素的序列

    val a = Array(10, 2, 3, 40, 5)
    val b = a.init
    println(b.mkString(","))    // 10, 2, 3, 40

inits: collection.Iterator[Array[T]]

对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象

    val a = Array(1, 2, 3, 4, 5)
    val 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个值
    */

val a=Array(1,2,3,4,5,6)
scala> a.inits
//res19: Iterator[Array[Int]] = non-empty iterator
scala> res19.toList            //非空迭代器需要toList转换为集合可显示。
//res20: List[Array[Int]] = List(Array(1, 2, 3, 4, 5, 6), Array(1, 2, 3, 4, 5), Array(1, 2, 3, 4), Array(1, 2, 3), Array(1, 2), Array(1), Array())

intersect(that: collection.Seq[T]): Array[T]

取两个集合的交集

val a = Array(1, 2, 3, 4, 5)
val b = Array(3, 4, 6)
val c = a.intersect(b)
println(c.mkString(","))    //return 3,4

isDefinedAt(idx: Int): Boolean

判断序列中是否存在指定索引

val a = Array(1, 2, 3, 4, 5)
println(a.isDefinedAt(1))   // true
 println(a.isDefinedAt(10))  // false

isEmpty: Boolean

判断当前序列是否为空

val a=Array(null)
println(a.isEmpty)   //null

isTraversableAgain: Boolean

判断序列是否可以反复遍历，该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回 false，除非被复写

val a=Array(1,2,3,4,5)
scala> a.isTraversableAgain
//res320: Boolean = true
scala> a.grouped(2)
//res321: Iterator[Array[Int]] = non-empty iterator
scala> a.grouped(2).isTraversableAgain
//res322: Boolean = false  //因为迭代器只能遍历一次

iterator: collection.Iterator[T]

对序列中的每个元素产生一个 iterator

 val a = Array(1, 2, 3, 4, 5)
 val b = a.iterator  //此时就可以通过迭代器访问 b

last: T

取得序列中最后一个元素

val a = Array(1, 2, 3, 4, 5)
 println(a.last) // return  5

lastIndexOf(elem: T): Int

取得序列中最后一个等于 elem 的元素的位置

val a = Array(1, 4, 2, 3, 4, 5)
println(a.lastIndexOf(4))   // return  4

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

取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前（包括）的元素中查找

val a = Array(1, 4, 2, 3, 4, 5)
println(a.lastIndexOf(4,3)) // return  1

lastIndexOfSlice[B >: A](that: GenSeq[B]): Int

判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引

 val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
 val b = Array(1, 4)
 println(a.lastIndexOfSlice(b))  // return  6

lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int

判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找

 val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
 val b = Array(1, 4)
 println(a.lastIndexOfSlice(b,4))    // return  0

lastIndexWhere(p: (T) ⇒ Boolean): Int
返回当前序列中最后一个满足条件 p 的元素的索引

val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
 val b = Array(1, 4)
 println(a.lastIndexWhere( {x:Int => x<2}))  // return  6

lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int

返回当前序列中最后一个满足条件 p 的元素的索引，可以指定在 end 之前（包括）的元素中查找

 val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
 val b = Array(1, 4)
 println(a.lastIndexWhere( {x:Int => x<2},2))    // return  0

lastOption: Option[T]

返回当前序列中最后一个对象

 val a = Array(1, 2, 3, 4, 5)
 println(a.lastOption)   // return  Some(5)

length: Int

返回当前序列中元素个数

val a = Array(1, 2, 3, 4, 5)
 println(a.length)   // return  5

lengthCompare(len: Int): Int

比较序列的长度和参数 len，根据二者的差值返回不同的值

 x <  0       if this.length <  len
 x == 0       if this.length == len
 x >  0       if this.length >  len

val a=Array(1,2,3,4,5,6)
a.lengthCompare(9)  //-3  //a.size-9=-3为值差
a.lengthCompare(1)  //5   //6-1=5

map[B](f: (A) ⇒ B): Array[B]

对序列中的元素数据结构的改变。

 val a = Array(1, 2, 3, 4, 5)
 val b = a.map( {x:Int => x*10})
 println(b.mkString(","))    // 10,20,30,40,50

max: A

返回序列中最大的元素

 val a = Array(1, 2, 3, 4, 5)
 println(a.max)  // return  5

maxBy[B](f: (A) ⇒ B): A

返回序列中第一个符合条件的元素。取不到符合条件的则取数组的第一个元素。

val a=Array(2,3,4,1)
a.maxBy(x=>x>2)  //3   取符合条件的第一个元素
a.maxBy(x=>x>4)  //2   取不到符合条件的则取数组的第一个元素

min

取数组内最小的元素

val  a=Array(3,4,2,1,5)
scala> a.min                  //1

minBy

第一个元素不满足条件就返回第一个元素；
所有元素都满足条件也返回第一个元素；
第一个元素满足的情况下返回从第二个开始第一个不满足的元素。

val a=Array(1,2,3,4,5,6)
scala> a.minBy(_<2)
//res67: Int = 2

scala> a.minBy(_>2)
//res68: Int = 1

scala> a.minBy(_<3)
//res69: Int = 3

scala> val a=Array(3,2,1,5)
//a: Array[Int] = Array(3, 2, 1, 5)
scala> a.minBy(_<1)
//res76: Int = 3   
scala> a.minBy(_<2)
//res77: Int = 3  //第一个元素不满足就返回第一个元素
scala> a.minBy(_<6)
//res79: Int = 3   //所有元素都满足也返回第一个元素
scala> a.minBy(_<4)
//res83: Int=5   //有元素满足就返回第一个不满足的元素

scala> a.minBy(_>3)
//res80: Int = 3   //第一个元素不满足就返回第一个元素
scala> a.minBy(_>2)
//res81: Int = 2   //第一个满足的情况下返回第一个不满足的元素。
scala> a.minBy(_>1)
//res82: Int = 1
scala> a.minBy(x=>x>0)
//res324: Int = 1   //所有元素都满足条件则返回第一个元素

mkString: String

将所有元素组合成一个字符串

val a = Array(1, 2, 3, 4, 5)
println(a.mkString) // return  12345

mkString(sep: String): String

将所有元素组合成一个字符串，以 sep 作为元素间的分隔符

val a = Array(1, 2, 3, 4, 5)
println(a.mkString(","))    // return  1,2,3,4,5

mkString(start: String, sep: String, end: String): String

将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

val a = Array(1, 2, 3, 4, 5)
 println(a.mkString("{",",","}"))    // return  {1,2,3,4,5}

nonEmpty: Boolean

判断序列不是空

val a=Array(null)
println(a.nonEmpty)   //true

padTo(len: Int, elem: A): Array[A]

补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

 val a = Array(1, 2, 3, 4, 5)
 val b = a.padTo(7,9)    //需要一个长度为 7  的新序列，空出的填充 9
 println(b.mkString(","))    // return  1,2,3,4,5,9,9
 val c=a.padTo(3,9)    //需要一个长度为3的新序列，空出的填充9
 println(b.mkString(","))  //return 1,2,3,4,5

par: ParArray[T]

返回一个并行实现，产生的并行序列，不能被修改

 val a = Array(1, 2, 3, 4, 5)
 val b = a.par   //  "ParArray" b.size = 5

 val a=Array(4,3,2,6)
scala> a.par.map(x=>x>2)
//res251: scala.collection.parallel.mutable.ParArray[Boolean] = ParArray(true, false, false, true)

scala> a.par.map(x=>x+1)
//res252: scala.collection.parallel.mutable.ParArray[Int] = ParArray(4, 3, 2, 6)   
//mutable 转化为可变的。

scala> a.map(x=>x+1)
//res253: Array[Int] = Array(4, 3, 2, 6)

partition(p: (T) ⇒ Boolean): (Array[T], Array[T])

按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分

val a=Array(1,2,3)
scala> a.partition(x=>x%2==0)
res86: (Array[Int], Array[Int]) = (Array(2),Array(1, 3)) //二元组

scala> a.partition(x=>x%2==0)._1
res88: Array[Int] = Array(2)
scala> a.partition(x=>x%2==0)._2
res89: Array[Int] = Array(1, 3)

scala> a.groupBy(x=>x%2==0)
res87: scala.collection.immutable.Map[Boolean,Array[Int]] = Map(false -> Array(1, 3), true -> Array(2))

patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]

批量替换，从原序列的 索引from 处开始，后面的 replaced 数量个元素，将被替换成序列 that

scala> val a=Array(1,2,3,4,5,6,7,8,9)
//a: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> val b=Array(11,12,13)
//b: Array[Int] = Array(11, 12, 13)
scala> a.patch(3,b,1)
//res93: Array[Int] = Array(1, 2, 3, 11, 12, 13, 5, 6, 7, 8, 9)  //从a的哪里开始替换，替换的序列，替换a的元素数
scala> a.patch(3,b,2)
//res94: Array[Int] = Array(1, 2, 3, 11, 12, 13, 6, 7, 8, 9)
scala> a.patch(3,b,4)
//res95: Array[Int] = Array(1, 2, 3, 11, 12, 13, 8, 9)
scala> a.patch(3,b,7)
//res96: Array[Int] = Array(1, 2, 3, 11, 12, 13)  //当a剩余的元素数少时就把b拿过来后不补啥。。

permutations: collection.Iterator[Array[T]]

排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样

scala> val a=Array(1,2,3)
//a: Array[Int] = Array(1, 2, 3)
scala> a.permutations
//res98: Iterator[Array[Int]] = non-empty iterator
scala> a.permutations.toList
//res99: List[Array[Int]] = List(Array(1, 2, 3), Array(1, 3, 2), Array(2, 1, 3), Array(2, 3, 1), Array(3, 1, 2), Array(3, 2, 1))

scala> a.combinations(2).toList
//res100: List[Array[Int]] = List(Array(1, 2), Array(1, 3), Array(2, 3))
scala> a.combinations(3).toList
//res101: List[Array[Int]] = List(Array(1, 2, 3))

prefixLength(p: (T) ⇒ Boolean): Int

给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p

 val a = Array(1,2,3,4,1,2,1,4)
 val b = a.prefixLength( {x:Int => x<3}) // b = 2

product: A

返回所有元素乘积的值

 val a = Array(1,2,3,4,5)
 val b = a.product       // b = 120  （1*2*3*4*5）

reduce&reduceLeft&reduceRight

scala> val a=Array(3,4,2,1,5,6)
//a: Array[Int] = Array(3, 4, 2, 1, 5, 6)

scala> a.reduce((x,y)=>x+y)
//res108: Int = 21

scala> a.reduce((x,y)=>{println(x,y);x+y})
/*
(3,4)
(7,2)
(9,1)
(10,5)
(15,6)
res109: Int = 21
*/
scala> a.reduceLeft((x,y)=>{println(x,y);x+y})
/*
(3,4)
(7,2)
(9,1)
(10,5)
(15,6)
res110: Int = 21
*/
scala> a.reduceLeft((x,y)=>{println(x,y);x-y})
/*
(3,4)
(-1,2)
(-3,1)
(-4,5)
(-9,6)
res113: Int = -15
*/
scala> a.reduceRight((x,y)=>{println(x,y);x+y})
/*
(5,6)
(1,11)
(2,12)
(4,14)
(3,18)
res111: Int = 21
*/
scala> a.reduceRight((x,y)=>{println(x,y);x-y})
/*
(5,6)
(1,-1)
(2,2)
(4,0)
(3,4)
res112: Int = -1
*/

reverse: Array[T]

反转序列

 val a = Array(1,2,3,4,5)
 val b = a.reverse
 println(b.mkString(","))    //5,4,3,2,1

reverseIterator: collection.Iterator[T]

反向生成迭代

scala> val a=Array(1,2,3)
//a: Array[Int] = Array(1, 2, 3)

scala> a.reverseIterator
//res334: Iterator[Int] = non-empty iterator

scala> a.reverseIterator.toList
//res335: List[Int] = List(3, 2, 1)

reverseMap[B](f: (A) ⇒ B): Array[B]

同 map 方向相反

 val a = Array(1,2,3,4,5)
 val b = a.reverseMap( {x:Int => x*10} )
 println(b.mkString(","))    // 50,40,30,20,10

sameElements(that: GenIterable[A]): Boolean

判断两个序列是否顺序和对应位置上的元素都一样

 val a = Array(1,2,3,4,5)
 val b = Array(1,2,3,4,5)
 println(a.sameElements(b))  // true
 
 val c = Array(1,2,3,5,4)
 println(a.sameElements(c))  // false

scan&scanLeft&scanRight

用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值

scala> val a=Array(3,2,1,5)
a: Array[Int] = Array(3, 2, 1, 5)

def seq(x:Int,y:Int):Int={
  println("seq",x,y)
  x+y
}

scala> a.scan(5)(seq)
/*
(seq,5,3)
(seq,8,2)
(seq,10,1)
(seq,11,5)
res125: Array[Int] = Array(5, 8, 10, 11, 16)
*/
scala> a.fold(5)(seq)
/*
(seq,5,3)
(seq,8,2)
(seq,10,1)
(seq,11,5)
res303: Int = 16
*/

scala> a.scanLeft(5)(seq)
/*
(seq,5,3)
(seq,8,2)
(seq,10,1)
(seq,11,5)
res305: Array[Int] = Array(5, 8, 10, 11, 16)  //打印结果与运算顺序相同
*/
scala> a.scanRight(5)(seq)
/*
(seq,5,5)
(seq,1,10)
(seq,2,11)
(seq,3,13)
res306: Array[Int] = Array(16, 13, 11, 10, 5)   //打印结果与运算顺序相反
*/

segmentLength(p: (T) ⇒ Boolean, from: Int): Int

从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度

val a=Array(3,2,1,5)
scala> a.segmentLength((x=>x>2),5)
//res307: Int = 0  超出序列返回0

scala> a.segmentLength((x=>x>2),1)
//res308: Int = 0   //从哪个元素开始该元素都不满足也返回0

scala> a.segmentLength((x=>x>4),1)
//res309: Int = 0

scala> a.segmentLength((x=>x<4),1)
//res310: Int = 2

seq: collection.mutable.IndexedSeq[T]

产生一个引用当前序列的 sequential 视图

scala> a
//res243: Array[Array[Int]] = Array(Array(2), Array(4, 5))
scala> a.seq
//res244: scala.collection.mutable.IndexedSeq[Array[Int]] = WrappedArray(Array(2), Array(4, 5))

size: Int

序列元素个数，同 length

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.size
//res245: Int = 5
scala> a.length
//res246: Int = 5

slice(from: Int, until: Int): Array[T]

取出当前序列中，from 到 until 之间的片段

 val a = Array(1,2,3,4,5)
 val b = a.slice(1,3)   //左闭右开
 println(b.mkString(","))    // 2,3 

sliding(size: Int)& sliding(size: Int, step: Int):

从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止。可以设置步进 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始

scala> val a=Array(1,2,3,4,5,6,7,8,9,10,11,12,13)
//a: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

scala> a.sliding(3,1)
//res9: Iterator[Array[Int]] = non-empty iterator

scala> a.sliding(3).toList   //默认跳步1。即等同于a.sliding(3,1).toList
//res10: List[Array[Int]] = List(Array(1, 2, 3), Array(2, 3, 4), Array(3, 4, 5), Array(4, 5, 6), Array(5, 6, 7), 
                           //Array(6, 7, 8), Array(7, 8, 9), Array(8, 9, 10), Array(9, 10, 11), Array(10, 11, 12), Array(11, 12, 13))

scala> a.sliding(3,3).toList
//res11: List[Array[Int]] = List(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9), Array(10, 11, 12), Array(13))

scala> a.sliding(3,5).toList
//res12: List[Array[Int]] = List(Array(1, 2, 3), Array(6, 7, 8), Array(11, 12, 13)) 

scala> a.sliding(3,6).toList
//res13: List[Array[Int]] = List(Array(1, 2, 3), Array(7, 8, 9), Array(13))   //加上跳步>1后，即使前面规定三个元素为一个数组，也会出现单个或者两个元素的数组。

sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]

按指定的排序规则排序

scala> val arr=Array(("hello",4),("world",1),("scala",3),("java",6))
//arr: Array[(String, Int)] = Array((hello,4), (world,1), (scala,3), (java,6))

scala> arr.sorted
//res18: Array[(String, Int)] = Array((hello,4), (java,6), (scala,3), (world,1))  //根据首字母

scala> arr.sortBy(x=>x._2)
//res19: Array[(String, Int)] = Array((world,1), (scala,3), (hello,4), (java,6))

scala> arr.sortBy(x=> -x._2)
//res20: Array[(String, Int)] = Array((java,6), (hello,4), (scala,3), (world,1))

scala> arr.sortBy(x=>{ -1*x._2})
//res21: Array[(String, Int)] = Array((java,6), (hello,4), (scala,3), (world,1))

scala> arr.sortWith((x,y)=>x._2>y._2)
//res22: Array[(String, Int)] = Array((java,6), (hello,4), (scala,3), (world,1))

sortWith(lt: (T, T) ⇒ Boolean): Array[T]

自定义排序方法 lt

scala> val a=Array(3,2,6,5,8,9,4)
//a: Array[Int] = Array(3, 2, 6, 5, 8, 9, 4)

scala> val b=a.sortWith(_.compareTo(_)>0)
//b: Array[Int] = Array(9, 8, 6, 5, 4, 3, 2)

scala> val b=a.sortWith((x,y)=>x.compareTo(y)>0)
//b: Array[Int] = Array(9, 8, 6, 5, 4, 3, 2)

scala> val b=a.sortWith((x:Int,y:Int)=>x.compareTo(y)>0)
//b: Array[Int] = Array(9, 8, 6, 5, 4, 3, 2)

scala> val b=a.sortWith((x:Int,y:Int)=>{println(x,y);x.compareTo(y)>0})
/*
(2,3)
(3,2)
(6,2)
(6,2)
(6,3)
(5,3)
(5,6)
(6,5)
(8,3)
(8,5)
(8,6)
(9,5)
(9,6)
(9,8)
(4,5)
(5,4)
(4,2)
(4,3)
b: Array[Int] = Array(9, 8, 6, 5, 4, 3, 2)

sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]

使用默认的排序规则对序列排序

 val a = Array(3,2,1,4,5)
 val b = a.sorted    
 println(b.mkString(","))    // 1,2,3,4,5

span(p: (T) ⇒ Boolean): (Array[T], Array[T])

分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合

 val a = Array(3,2,1,4,5)
 val b = a.span( {x:Int => x > 2})
 println(b._1.mkString(","))     //  3
 println(b._2.mkString(","))     //  2,1,4,5

splitAt(n: Int): (Array[T], Array[T])

从指定位置开始，把序列拆分成两个集合

 val a = Array(3,2,1,4,5)
 val b = a.splitAt(2)
 println(b._1.mkString(",")) //  3,2
 println(b._2.mkString(",")) //  1,4,5

startsWith[B](that: GenSeq[B], offset: Int): Boolean

从指定偏移处，是否以某个序列开始

 val a = Array(0,1,2,3,4,5)
 val b = Array(1,2)
 println(a.startsWith(b,1))      //  true

 val a = Array(1,2,3,4,5)
 val b = Array(1,2)
 println(a.startsWith(b))        //  true  //默认为a.startsWith(b,0)

stringPrefix: String

返回 toString 结果的前缀或者类型。

scala> a
//res42: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)
scala> a.stringPrefix
//res41: String = [I

scala> val l=List(1,2,3)
//l: List[Int] = List(1, 2, 3)
scala> l.stringPrefix
//res43: String = List

scala> val str="hello"
//str: String = hello
scala> str.stringPrefix
//res44: String = String

scala> arr
//res45: Array[(String, Int)] = Array((hello,4), (world,1), (scala,3), (java,6))
scala> arr.stringPrefix
//res46: String = Tuple2;

scala> a.toSeq
//res47: Seq[Int] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8)
scala> res47.stringPrefix
//res48: String = WrappedArray
                 
scala> import scala.collection.mutable._
//import scala.collection.mutable._
scala> val b:ArrayBuffer[Char]=ArrayBuffer()
//b: scala.collection.mutable.ArrayBuffer[Char] = ArrayBuffer()
scala> b.stringPrefix
//res50: String = ArrayBuffer 

subSequence(start: Int, end: Int): CharSequence

返回 start 和 end 间的字符序列

 val chars = Array('a','b','c','d')
 val b = chars.subSequence(1,3)
     println(b.toString)     //  bc

sum: A

序列求和，元素需为Numeric[T]类型

 val a = Array(1,2,3,4,5)
 val b = a.sum       //  15

tail: Array[T]

返回除了当前序列第一个元素的其它元素组成的序列

 val a = Array(1,2,3,4,5)
 val b = a.tail      //  2,3,4,5

tails

返回迭代器，于inits相反

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

scala> a.tails
//res251: Iterator[Array[Int]] = non-empty iterator
scala> a.tails.toList
//res252: List[Array[Int]] = List(Array(1, 2, 3, 4, 5), Array(2, 3, 4, 5), Array(3, 4, 5), Array(4, 5), Array(5), Array())

scala> a.init
//res253: Array[Int] = Array(1, 2, 3, 4)
scala> a.inits
//res254: Iterator[Array[Int]] = non-empty iterator
cala> a.inits.toList
//res255: List[Array[Int]] = List(Array(1, 2, 3, 4, 5), Array(1, 2, 3, 4), Array(1, 2, 3), Array(1, 2), Array(1), Array())

take(n: Int): Array[T]

返回当前序列中前 n 个元素组成的序列

 val a = Array(1,2,3,4,5)
 val b = a.take(3)       //  1,2,3

takeRight(n: Int): Array[T]

返回当前序列中，从右边开始，选择 n 个元素组成的序列

 val a = Array(1,2,3,4,5)
 val b = a.takeRight(3)      //  3,4,5

takeWhile(p: (T) ⇒ Boolean): Array[T]

返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列

 val a = Array(1,2,3,4,5)
 val b = a.takeWhile( {x:Int => x < 3})      //  1,2

toArray: Array[A]

转换成 Array 类型

scala> val a=List(1,2,3,4,5)
//a: List[Int] = List(1, 2, 3, 4, 5)
scala> a.toArray
//res256: Array[Int] = Array(1, 2, 3, 4, 5)

toBuffer[A1 >: A]: Buffer[A1]

转换成 Buffer 类型

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toBuffer
//res257: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

toIndexedSeq: collection.immutable.IndexedSeq[T]

转换成 IndexedSeq 类型

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toIndexedSeq
//res259: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4, 5)

toIterable: collection.Iterable[T]

转换成可迭代的类型

在scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toIterable
//res260: Iterable[Int] = WrappedArray(1, 2, 3, 4, 5)

toIterator: collection.Iterator[T]

转换成迭代器

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toIterator
//res263: Iterator[Int] = non-empty iterator
scala> a.toIterator.toList
//res264: List[Int] = List(1, 2, 3, 4, 5)

toList: List[T]

同 List 类型

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toList
//res265: List[Int] = List(1, 2, 3, 4, 5)

toMap[T, U]: Map[T, U]

同 Map 类型，需要被转化序列中包含的元素时为 Tuple2 类型数据

 val chars = Array(("a","b"),("c","d"),("e","f"))
 val b = chars.toMap
    println(b)      //Map(a -> b, c -> d, e -> f)

toSeq: collection.Seq[T]

转换成Seq 类型

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toSeq
//res266: Seq[Int] = WrappedArray(1, 2, 3, 4, 5)

toSet[B >: A]: Set[B]

转化成 Set 类型

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toSet
//res267: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

toStream: collection.immutable.Stream[T]

转换成Stream 类型

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toStream
//res268: scala.collection.immutable.Stream[Int] = Stream(1, ?)

toVector: Vector[T]

转化成Vector 类型

scala> val a=Array(1,2,3,4,5)
//a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.toVector
//res269: Vector[Int] = Vector(1, 2, 3, 4, 5)

toTraversable

使之可以反复遍历。主要针对于迭代器

scala> val a=Array(1,2,3)
scala> val d=a.toIterator
//d: Iterator[Int] = non-empty iterator
scala> for(i<-d)println(i)
/*
1
2
3
*/
scala> for(i<-d)println(i)
//空   迭代器不可反复遍历

scala> val e=a.toIterator.toTraversable
//e: Traversable[Int] = Stream(1, ?)
scala> for(x<-e)println(x)
/*
1
2
3
*/
scala> for(x<-e)println(x)    //可反复遍历
/*
1
2
3
*/ 

transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]

• def transpose[U](implicit asArray: Array[String] => Array[U]): Array[Array[U]]
• def transpose[B](implicit asTraversable: Array[String] => scala.collection.GenTraversableOnce[B]): scala.collection.mutable.IndexedSeq[scala.collection.mutable.IndexedSeq[B]]
• asArray：传入数组，即为二维数组。

scala> val arr=Array(Array("a","b"),Array("c","d"),Array("e","f"),Array("g","h"))
//arr: Array[Array[String]] = Array(Array(a, b), Array(c, d), Array(e, f), Array(g, h))
scala> arr.transpose
//res62: Array[Array[String]] = Array(Array(a, c, e, g), Array(b, d, f, h))

scala> val arr=Array(Array("a","b"),Array("c","d"),Array("e","f"),Array("g"))
//arr: Array[Array[String]] = Array(Array(a, b), Array(c, d), Array(e, f), Array(g))
scala> arr.transpose
//res63: Array[Array[String]] = Array(Array(a, c, e, g), Array(b, d, f))

transform

scala> val chars=Array(("a","b"),("c","d"))
//chars: Array[(String, String)] = Array((a,b), (c,d))
scala> chars.transform(x=>(x._1+"1",x._2+"2"))
//res80: scala.collection.mutable.WrappedArray[(String, String)] = WrappedArray((a1,b2), (c1,d2))

union(that: collection.Seq[T]): Array[T]

联合两个序列，同操作符 ++

 val a = Array(1,2,3,4,5)
 val b = Array(6,7)
 val c = a.union(b)
 println(c.mkString(","))        // 1,2,3,4,5,6,7

unzip

• def unzip[T1, T2](implicit asPair: ((Int, Int)) => (T1, T2),implicit ct1: scala.reflect.ClassTag[T1],implicit ct2: scala.reflect.ClassTag[T2]): (Array[T1], Array[T2])
• def unzip[A1, A2](implicit asPair: ((Int, Int)) => (A1, A2)): (scala.collection.mutable.IndexedSeq[A1], scala.collection.mutable.IndexedSeq[A2])
• asPair：作为一对，array数组里的元素为二元组。

scala> val chars=Array(("a","b"),("c","d"))
//chars: Array[(String, String)] = Array((a,b), (c,d))
scala> chars.unzip
//res79: (Array[String], Array[String]) = (Array(a, c),Array(b, d))

unzip3

• def unzip3[T1, T2, T3](implicit asTriple: ((Int, Int)) => (T1, T2, T3),implicit ct1: scala.reflect.ClassTag[T1],implicit ct2: scala.reflect.ClassTag[T2],implicit ct3: scala.reflect.ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
• def unzip3[A1, A2, A3](implicit asTriple: ((Int, Int)) => (A1, A2, A3)): (scala.collection.mutable.IndexedSeq[A1], scala.collection.mutable.IndexedSeq[A2], scala.collection.mutable.IndexedSeq[A3])
• asTriple：输入三元组，即数组里的元素为三元组。

scala> val c=Array((1,2,3),(4,5,6),(7,8,9))
//c: Array[(Int, Int, Int)] = Array((1,2,3), (4,5,6), (7,8,9))
scala> c.unzip3
//res218: (Array[Int], Array[Int], Array[Int]) = (Array(1, 4, 7),Array(2, 5, 8),Array(3, 6, 9))

update(i: Int, x: T): Unit

将序列中 i 索引处的元素更新为 x
数组随之改变

 val a = Array(1,2,3,4,5)
 a.update(1,9)
 println(a.mkString(","))        //1,9,3,4,5

updated(index: Int, elem: A): Array[A]

将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
原数组不变

 val a = Array(1,2,3,4,5)
 val b = a.updated(1,9)
 println(b.mkString(","))        //1,9,3,4,5
 println(a.mkString(","))        //1,2,3,4,5

view(from: Int, until: Int): IndexedSeqView[T, Array[T]]

返回 from 到 until 间的序列，不包括 until 处的元素

scala> a
//res87: Array[Int] = Array(1, 100, 3, 4, 5, 6, 7, 8)
scala> a.view(0,3)
//res88: scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(...)
scala> res88.toList
//res89: List[Int] = List(1, 100, 3)

withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]

根据条件 p 过滤元素

scala> a
//res90: Array[Int] = Array(1, 100, 3, 4, 5, 6, 7, 8)
scala> a.withFilter(x=>x>0)
//res91: scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@1ada7fa8
scala> a.withFilter(x=>x>0).map(x=>x)
//res92: Array[Int] = Array(1, 100, 3, 4, 5, 6, 7, 8)
scala> a.withFilter(x=>x>3).map(x=>x)
//res93: Array[Int] = Array(100, 4, 5, 6, 7, 8)

scala> a.filter(x=>x>3)
//res94: Array[Int] = Array(100, 4, 5, 6, 7, 8)

zip[B](that: GenIterable[B]): Array[(A, B)]

将两个序列对应位置上的元素组成一个pair序列

 val a = Array(1,2,3,4,5)
 val b = Array(5,4,3,2,1)
 val c = a.zip(b)
 println(c.mkString(","))        //(1,5),(2,4),(3,3),(4,2),(5,1)

zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]

同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列短，空出的填充为 thisElem，如果 that 短，填充为 thatElem

scala> val arr1=Array("dsj1","dsj2","dsj3","ds4")
//arr1: Array[String] = Array(dsj1, dsj2, dsj3, ds4)
scala> val arr2=Array("bigdata1","bigdata2","bigdata3","bigdata4","bigdata5","bigdata6")
//arr2: Array[String] = Array(bigdata1, bigdata2, bigdata3, bigdata4, bigdata5, bigdata6)
scala> arr1.zipAll(arr2,"1","2")
//res100: Array[(String, String)] = Array((dsj1,bigdata1), (dsj2,bigdata2), (dsj3,bigdata3), (ds4,bigdata4), (1,bigdata5), (1,bigdata6))
scala> arr2.zipAll(arr1,"2","1")
//res101: Array[(String, String)] = Array((bigdata1,dsj1), (bigdata2,dsj2), (bigdata3,dsj3), (bigdata4,ds4), (bigdata5,1), (bigdata6,1))

zipWithIndex: Array[(A, Int)]

序列中的每个元素和它的索引组成一个序列

 val a = Array(10,20,30,40)
 val b = a.zipWithIndex
 println(b.mkString(","))        //(10,0),(20,1),(30,2),(40,3)