Scala中Array方法大全

川长思鸟来 2023-02-24 14:26 154阅读 0赞

## Scala Array ##

Scala 语言中提供的数组是用来存储固定大小的同类型元素。  
声明数组变量并不是声明 num0、num1、…、num99 一个个单独的变量，而是声明一个就像 numbers 这样的变量，然后使用 numbers\[0\]、numbers\[1\]、…、numbers\[99\] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。  
数组的第一个元素索引为0，最后一个元素的索引为元素总数减1。

#### 声明数组 ####

Scala 数组声明的语法格式：

var z:Array[String] = new Array[String](3)
    或
    var z = Array[String](3)

以上语法中，z 声明一个字符串类型的数组，数组长度为 3 ，可存储 3 个元素。我们可以为每个元素设置值，并通过索引来访问每个元素，如下所示

z(0) = "a"; z(1) = "b"; z(2) = "c"

#### 定义数组 ####

var z = Array("a","b","c")

#### 对数组进行处理 ####

当处理数组元素时候，我们通常使用基本的 for 循环

object Test { 
       def main(args: Array[String]) { 
          var myList = Array(1.9, 2.9, 3.4, 3.5)
    
    // 输出所有数组元素
    for ( x <- myList ) { 
    println( x )
    }
    }
    }

结果为：

1.9
    2.9
    3.4
    3.5

## Scala List(列表) ##

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同:  
列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。  
**列表的元素类型 T 可以写成 List\[T\]**

### 列表基本操作： ###

Scala列表有三个基本操作：

1.  **head 返回列表第一个元素**
2.  **tail 返回一个列表，包含除了第一元素之外的其他元素**
3.  **isEmpty 在列表为空时返回true**

对于Scala列表的任何操作都可以使用这三个基本操作来表达。

## 下面就说下List常用方法： ##

### . addString(b: StringBuilder) ###

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

var a = Array(1,2,3,4)    
    var b = new StringBuilder()    
    var c = a.addString(b)  // c中的内容是 1234

### . addString(b: StringBuilder, start: String, sep: String, end: String) ###

同上，在首尾各加一个字符串，用逗号分隔

var a = Array(1,2,3,4)    
    var b = new StringBuilder()    
    var c = a.addString(b,"{",",","}")  // 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+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

### . apply(i: Int) ###

取出指定索引处的元素

var first = apply(0) // 取出第一个元素

### \++ ###

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

val a = Array(1,2，3)    
    val b = Array(4,5，6)    
    val c = a ++ b
    
    c的值 （1,2,3,4，5，6)

### \++: ###

这个方法同上一个方法类似，后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型。

### \+: ###

在数组前面添加元素，返回新的数组

val a = Array(1,2)    
       val c = 3 +: a 
    
       c的值是 （3,1,2）

### :+ ###

在数组后面添加元素，返回新的数组

val a = Array(1,2)    
       val c = 3 :+ a 
    
       c的值是 （1,2,3）

### /: ###

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

val a = Array(1,2,3,4)    
    val c = (5 /: a)(_+_)   // 1+2+3+4+5 
    val d = (5 /: a)(_*_)   // 1*2*3*4*5
    println("c:"+c)   // c:15 
    println("d:"+d)   // d:120

### :\\ ###

foldRight的简写,foldRight就是逆序集合，然后调用foldLeft,  
对数组中所有的元素进行相同的操作

### :： ###

在数组前面添加元素，要加的新值必须放在双冒号前面

val a = Array(1,2，3)    
     val b = 4    
     val c = b ：： a 
    
     c的值 （4,1,2,3)

### : : : ###

合并两个数组，必须是两个List类型的集合。并返回一个新的数组，新数组包含左右两个数组的内容。

### . canEqual(that: Any): Boolean ###

判断2个数组是否可以比较

val a = Array(1,2,3,4)
    val b = Array(33,65)
    a.canEqual(b)
    
    结果：true

### . charAt(index: Int): Char ###

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

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

### . clone() ###

拷贝一个数组

val a = Array(1,2,3,4)
    val b = a.clone()
    
    b结果   (1,2,3,4)

### . collect() ###

通过执行一个并行计算（偏函数），只处理自己给的条件的其中那一部分，想要哪部分就输出那部分,剩余部分没有条件判断就直接输出，最后得到一个新的数组

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

### . collectFirst() ###

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

val arr = Array(1,'a',"b")
    //定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作 
    val func:PartialFunction[Any,Int] = {     
    case x:Int => x*100  
    }
    //计算 
    val value = arr.collectFirst(func)  
    println("value:"+value)
    //另一种写法
    val value = arr.collectFirst({ case x:Int => x*100})

### . combinations(n: Int) ###

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

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

## .contains() ##

判断数组中是否包含指定的值,有就返回true，没有就返回flase

val arr = Array("a","b","c")
    arr.contains("a")
    
    结果:true

### .containsSlice() ###

判断数组中是否包含另一个数组,数组中的值去一一比较，全部有就返回true，没有就返回flase

val a = Array(1,2,3,4)    
    val b = Array(2,3)    
    println(a.containsSlice(b)) 
    
    结果：true

### .copyToArray() ###

### .copyToArray(xs: Array\[A\], start: Int) ###

### .copyToArray(xs: Array\[A\], start: Int, len: Int) ###

把数组拷贝到另一个数组中，拷贝后定义的新数组如果长度不够用0补齐

val a = Array('a', 'b', 'c')
    val b : Array[Char] = new Array(5)
    a.copyToArray(b)    //b中元素 ['a','b','c',0,0]
    
    a.copyToArray(b,1)  //b中元素 [0,'a',0,0,0] 拷贝1个值到b中下标为1的地方
    
    a.copyToArray(b,1,2) //b中元素 [0,'a','b',0,0] 拷贝2个值到b中下标为1的地方

### .copyToBuffer() ###

将数组中的内容拷贝到Buffer中

val a = Array('a', 'b', 'c')
    val b:ArrayBuffer[Char]  = ArrayBuffer()
    a.copyToBuffer(b)
    println(b.mkString(","))

### .corresponds() ###

判断两个数组长度是否一样以及对应位置元素每个值是否全部符合某个条件。如果两个序列具有相同的元素数量并且每个值都符合条件p(x<y)=true，否则返回结果为true

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

val c = Array(1, 2, 3)
    val b = Array(4, 5,6)
    val a = Array(4, 1,2)
    val b = Array(4, 5)
    println(c.corresponds(b)(_<_))  //true 每个值全部符合条件才true
    println(c.corresponds(a)(_<_))  //false 有一个值符合条件false
    println(c.corresponds(d)(_<_))  //false 数组长度不一样不符合条件false

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

统计符合条件的元素个数,后面跟判断条件

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

### compose ###

组合其他函数形成一个新的函数

def f(s: String) = "f(" + s + ")" 
    def g(s: String) = "g(" + s + ")" 
    
    val fComposeG = f _ compose g _ 
    fComposeG("yay")      // f(g(yay))

### andThen ###

andThen 和 compose很像，但是调用顺序是先调用第一个函数，然后调用第二个

def f(s: String) = "f(" + s + ")" 
    def g(s: String) = "g(" + s + ")"
    
    val fAndThenG = f _ andThen g _ 
    fAndThenG("yay")           // g(f(yay))

### . 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

### .distinct ###

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

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

### .drop(n: Int) ###

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

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

### .dropRight(n: Int) ###

去掉尾部的 n 个元素后，作为一个新数组返回

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

### .dropWhile() ###

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

val a = Array(3, 2, 3,4)
    val c = a.dropWhile( { x:Int => x > 2} )//第一元素满足，第二个开始不满足，所以去除第一个满足条件的元素
    println(c.mkString(","))  //2,3,4
    
    val a = Array(1, 2, 3,4) 
    val c = a.dropWhile( { x:Int => x > 2} ) //第一个元素就不满足条件，所有返回整个数组
    println(c.mkString(","))  //1,2,3,4

### .endsWith() ###

判断数组中是否以其中某个元素结尾 ，是就返回true

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

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

判断当前数组是否包含符合条件的元素,有就返回true

val a = Array(1, 2, 3,4)
    println(a.exists( { x:Int => x==1} ))   //true
    println(a.exists( { x:Int => x==5} ))  //false

### . filter(p: (T) ⇒ Boolean) ###

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

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

### .filterNot(p: (T) ⇒ Boolean) ###

获取当前数组中不满足条件的元素，组成新的数组返回，与上面的 filter 作用相反

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

### .find(p: (T) ⇒ Boolean) ###

从数组中去查找第一个符合条件的元素

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

### .flatMap() ###

对当前数组的每个元素进行操作，结果放入新序列返回

val a = Array(1, 2, 3,4)
    val b = a.flatMap(x=>1 to x)
    println(b.mkString(","))
    
    //1,1,2,1,2,3,1,2,3,4
    //从1开始，分别对集合a的每个元素生成一个递增序列，过程如下
    1
    1,2
    1,2,3
    1,2,3,4

### . flatten ###

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

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

### .fold()(op: (A1, A1) ⇒ A1) ###

对序列中的每个元素进行二元运算，和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 = Array(1, 2, 3,4)
    val b = a.fold(5)(seqno)
    
    // 运算过程 从左边开始，每一次计算后的值，在重新给到左边去计算
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4
    
    val c = a.par.aggregate(5)(seqno,combine)
    
    // 运算过程 
    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

看上面的运算过程发现，**fold**中，seqno是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算

而**aggregate**中，seqno是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法combine进行处理

### .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)或
    val b = (5 /: a)(_+_)
    
    // 运算过程 
    从把初始值和数组左边开始运算，计算结果继续给到左边，继续和数组从左往右的下一个值开始运算
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4

### .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)或
    val b = (5 :\ a)(_+_)
    
    // 运算过程 从把初始值和数组右边开始运算，结果继续给到右边，继续和数组从右往左的下一个值开始运算
    seq_exp=4+5
    seq_exp=3+9
    seq_exp=2+12
    seq_exp=1+14

### .forall(x: (T) ⇒ Boolean) ###

检测序列中的每个元素是否都满足条件，如果全部满足，才返回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(x: (A) ⇒ Unit) ###

遍历序列中的元素，但是没有返回值

val a = Array(1, 2, 3,4)
    a.foreach(x => println(x*10))
    //结果
    10
    20
    30
    40

### .groupBy(x: (T) ⇒ K) ###

按条件分组，条件由 x匹配，返回值是Map类型，每个key对应一个数组

val a = Array(1, 2, 3,4)
    val b = a.groupBy( x => x match { 
    case x if (x < 3) => "small"
    case _ => "big"
     })
     //结果
     (small -> Array(1, 2), big -> Array(3, 4))

### .grouped(x: Int): collection.Iterator ###

按指定数量分组，每组有x个元素，返回一个集合,不满足指定数量的也分一组

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 ###

检测数组是否存在有限的长度，对应Stream这样的流数据，没有就返回false

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

### .head ###

返回当前数组的第一个元素

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

### .headOption: Option ###

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

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

### .indexOf(x: T): Int ###

返回当前值在数组中的索引，找到第一个对应值就返回索引

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

### .indexOf(elem: T, from: Int): Int ###

返回当前值在数组中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回

val a = Array(1, 3, 2, 3, 4)
    println(a.indexOf(3,2)) //从索引为2的地方开始往后查找，数组中含有3的地方的索引
    
    // return 3

### .indexOfSlice() ###

查找当前数组的元素中是否包含另一个数组的元素，找到一样的元素后并返回第一个匹配出现的元素的索引

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

### .indexWhere(x: (Int) ⇒ Boolean) ###

返回当前数组中第一个满足条件的元素的索引

val a = Array(1, 2, 3, 4)
    println(a.indexWhere( { x:Int => x>3}))  // return 3 只有4满足条件

### .indexWhere(x: (Int) ⇒ Boolean, from: Int): Int ###

返回当前数组中第一个满足条件的元素的索引,可以指定从 from 索引处开始

val a = Array(1, 2, 3, 4, 5, 6)
    println(a.indexWhere( { x:Int => x>3},4))    // return 4 索引4的位置的元素正好满足条件

### .indices ###

返回当前数组中的索引集合

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

### .init ###

返回当前数组中不包含最后一个元素的集合

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

### .inits.toList ###

对集合中的元素进行 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个值

### .intersect() ###

或 & 取两个数组的交集，也就是都有的元素

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(x: Int) ###

判断当前数组中是否存在指定索引

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

### .isEmpty ###

判断当前数组是否为空

### .isTraversableAgain ###

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

### .iterator ###

对数组中的每个元素产生一个 iterator

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

### . last ###

获取数组中最后一个元素

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

### . lastIndexOf(x) ###

获取数组中最后一个等于x 的元素的位置的下标

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

### .lastIndexOf(x, end: Int) ###

获取数组中最后一个等于x 的元素的位置的下标,可以指定在 end 之前（包括）的元素中查找

val a = Array(1, 4, 2, 3, 4, 5)
    println(a.lastIndexOf(4,3)) // return 1 从元素3之前的位置查找元素4的位置下标

### . lastIndexOfSlice() ###

判断当前数组中是否包含另一个数组中的所有元素，并返回最后一次出现该元素的位置处的索引，匹配不到返回-1

val a = Array(1, 4, 2, 3, 4, 5, 4)
    val c = Array(1, 4, 2, 3, 4, 5,1，4)
    val b = Array(1, 4)
    val d = Array(1,3)
    println(c.lastIndexOfSlice(b))  // return 6
    println(a.lastIndexOfSlice(b))  // return 0 
    println(a.lastIndexOfSlice(d))  // return -1

### .lastIndexOfSlice(x,end:Int) ###

判断当前数组中是否包含另一个数组中的所有元素，并返回最后一次出现该元素的位置处的索引，匹配不到返回-1;可以指定在 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(x: (T) ⇒ Boolean) ###

返回当前数组中最后一个满足条件 x的元素的索引

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
    println(b.lastIndexWhere( { x:Int => x<2}))  // return 0

### .lastIndexWhere(x: (T) ⇒ Boolean, end: Int) ###

返回当前数组中最后一个满足条件 x的元素的索引,可以指定在 end 之前（包括）的元素中查找

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

### .lastOption ###

返回当前数组中最后一个Option元素

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

### .length ###

返回当前数组中元素个数

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

### .lengthCompare ###

比较数组的长度和参数 len，根据二者的关系返回不同的值，比较规则是

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

### . map(x: (A) ⇒ B) ###

对数组中每个元素进行遍历x操作，并把操作后的全部值返回

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 ###

返回数组中最大的元素

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

### .maxBy(x: (A) ⇒ B) ###

返回数组中第一个符合条件的元素

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

### .min ###

返回数组中最小的元素

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

### .minBy(x: (A) ⇒ B) ###

返回数组中第一个不符合条件的元素

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

### .mkString ###

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

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

### .mkString(sep: String) ###

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

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

### .nonEmpty ###

判断数组不为空，返回true

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

### .padTo(len: Int, x: A) ###

后补齐数组长度的元素，如果当前数组长度小于 len，那么新产生的数组长度是 len，多出的几个位值填充 x的值，如果当前数组长度大于等于 len ，则返回当前数组所有元素

val a = Array(1, 2, 3, 4, 5)
    val b = a.padTo(7,9)    //需要一个长度为 7 的新数组，不够长度的用9填充
    val c = a.padTo(4,0)    //需要一个长度为4的新数组，长度够返回原来数组
    println(b.mkString(","))    // return 1,2,3,4,5,9,9
    println(c.mkString(","))    // return 1,2,3,4,5

### .par ###

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

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

### .partition(x: (Int) ⇒ Boolean) ###

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

val a = Array(1, 2, 3, 4, 5)
    val b:(Array[Int],Array[Int]) = a.partition( { x:Int => x % 2 == 0})
    println(b._1.mkString(","))     // return 2,4
    println(b._2.mkString(","))     // return 1,3,5

### .patch(from: Int, that: GenSeq\[A\], replaced: Int) ###

批量替换，从原数组的下标from 处开始，后面的 replaced 个元素，将被替换成新数组中的所有元素 that

val a = Array(1, 2, 3, 4, 5)
    val b = Array(3, 4, 6)
    val c = a.patch(1,b,2)
    println(c.mkString(","))    // return 1,3,4,6,4,5
     /**从 a 的第二个元素开始，取两个元素，即 2和3 ，这两个元素被替换为 b的内容*/

### .permutations: collection.Iterator ###

排列组合，数组中所有元素相乘就是组合后排列的结果，与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样

val a = Array(1, 2, 3, 4, 5)
    val b = a.permutations.toList      // b 中将有120个结果
    
     /**如果是combinations*/
     val b = a.combinations(5).toList    // b 中只有一个，因为不管怎样排列，都是这5个数字组成，所以只能保留第一个

### .prefixLength(x: (Int) ⇒ Boolean) ###

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

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

### .product ###

返回所有元素乘积的值

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

### .reduce ###

同 fold，不需要初始值,计算结果

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,5)
       val b = a.reduce(seqno)
       println(b)    // 15
       //计算过程
        seq_exp=1+2
        seq_exp=3+3
        seq_exp=6+4
        seq_exp=10+5

### .reduceLeft() ###

从左向右计算

### .reduceRight() ###

从右向左计算

### .reduceOption() ###

计算Option，参考reduce

### .reduceRightOption() ###

计算Option，参考reduceRight

### .reduceLeftOption() ###

计算Option，参考reduceLeft

### .reverse ###

反转数组中所有元素

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

### .reverseIterator ###

反向生成迭代

### .reverseMap() ###

同 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() ###

判断两个数组是否顺序和对应位置上的元素都一样，诗句返回true

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() ###

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

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,5)
      val b = a.scan(5)(seqno)
      println(b.mkString(","))    // 5,6,8,11,15,20

### .scanLeft() ###

从左向右计算

### .scanRight() ###

从右向左计算

### .segmentLength(x: (Int) ⇒ Boolean, from: Int) ###

从数组的 from 处开始向后查找，包含当前处，所有满足 x 的连续元素的长度

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

### .seq ###

产生一个引用当前数组的 sequential 视图

### .size ###

数组中元素个数，同 length

### .slice(from: Int, until: Int) ###

取出当前数组中，from 到 until 之间的所有值，不包含后面until那个值

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

### .sliding(size: Int) ###

从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止

val a = Array(1,2,3,4,5)
    val b = a.sliding(3).toList
      for(i<-0 to b.length - 1){ 
      val s = "第"+i+"个:"
      println(s.format(i,b(i).mkString(",")))
      }
     //结果
      第0个：1,2,3
      第1个：2,3,4
      第2个：3,4,5

### .sliding(size: Int, step: Int) ###

从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止

该方法，可以设置步数 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始

val a = Array(1,2,3,4,5)
    val b = a.sliding(3,2).toList//第一个从1开始， 第二个从3开始，因为步数是 2
    for(i<-0 to b.length - 1){ 
    val s = "第"+i+"个:"
    println(s.format(i,b(i).mkString(",")))
    }
    //结果
    第0个：1,2,3
    第1个：3,4,5

### .sortBy(x: (Int) ⇒ B) ###

按指定的排序规则排序

val a = Array(3,2,1,4,5)
    val b = a.sortBy( { x:Int => x})   //升序
    val c = a.sortBy( { x:Int => 0-x})   //降序
    println(b.mkString(","))    // 1,2,3,4,5
    println(c.mkString(","))    // 5,4,3,2,1

### .sortWith(x: (T, T) ⇒ Boolean) ###

自定义排序方法 x

val a = Array(3,2,1,4,5)
    val b = a.sortWith(_.compareTo(_) > 0)  // 大数在前
    println(b.mkString(","))    // 5,4,3,2,1

### .sorted ###

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

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

### .span(x: (Int) ⇒ Boolean) ###

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

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() ###

从指定位置的元素开始，把序列拆分成两个集合，第一部分包含当前元素

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() ###

从元素组指定下标处查找，是否以现在这个数组中的全部元素开始，不是就返回flase

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

### .startsWith() ###

是否以现在这个数组中的全部元素开始，不是就返回flase

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

### .stringPrefix ###

返回 toString 结果的前缀

val a = Array(0,1,2,3,4,5)
    println(a.toString())     //[I@3daa57fb
    val b = a.stringPrefix
    println(b)      //[I

### .subSequence(start: Int, end: Int) ###

返回 start 和 end 间的字符序列,不包含后面的end下标

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

### .sum ###

数组中的所有元素求和

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

### .tail ###

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

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

### .take(n: Int) ###

返回当前数组中前 n 个元素组成的新数组

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

### .takeRight(n: Int) ###

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

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

### .takeWhile(x: (Int) ⇒ Boolean) ###

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

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

### .toArray ###

转换成 Array 类型

### .toBuffer ###

返回缓冲区，包含了列表的所有元素

### .toIndexedSeq ###

转换成 IndexedSeq 类型

## .toIterable ##

转换成可迭代的类型

## .toIterator ##

同 iterator 方法

### .toList ###

同 List 类型

### .toMap ###

同 Map 类型

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

### .toSeq ###

同 Seq 类型

### .toSet ###

同 Set 类型

### .toStream ###

同 Stream 类型,懒惰型List

### .toString() ###

列表转换为字符串

### .transpose ###

矩阵转换，二维数组行列转换

val chars = Array(Array("a","b"),Array("c","d"),Array("e","f"))
    val b = chars.transpose
    //结果
    Array(Array(a, c, e), Array(b, d, f))

### .union() ###

合并两个数组，同操作符 ++

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 ###

将含有两个元素的数组，必须是2个元素组成的2个数组，都把第一个元素取出然后组成一个新数组，同时拿出来第二个元素组成另一个新数组，依次类推操作

val chars = Array(("a","b"),("c","d"))
    val b = chars.unzip
    println(b._1.mkString(","))     //a,c
    println(b._2.mkString(","))     //b,d

### .unzip3 ###

将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列

val chars = Array(("a","b","x"),("c","d","y"),("e","f","z"))
    val b = chars.unzip3
    println(b._1.mkString(","))     //a,c,e
    println(b._2.mkString(","))     //b,d,f
    println(b._3.mkString(","))     //x,y,z

### .update(i: Int, x: T) ###

将数组中 i 索引处的元素更新为 x

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

### .updated(i: Int, x: T) ###

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

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

### .view(from: Int, until: Int) ###

返回 下标from 到 until 间的数组，不包括 until 处的元素

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

### .withFilter(x: (Int) ⇒ Boolean) ###

根据条件 x 过滤元素

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

### .zip() ###

将两个数组对应位置上的元素组成一个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(that: x, thisElem: A, thatElem: B) ###

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

val a = Array(1,2,3,4,5,6,7)
    val b = Array(5,4,3,2,1)
    val c = a.zipAll(b,9,8)  //(1,5),(2,4),(3,3),(4,2),(5,1),(6,8),(7,8)
    
    val a = Array(1,2,3,4)
    val b = Array(5,4,3,2,1)
    val c = a.zipAll(b,9,8)         //(1,5),(2,4),(3,3),(4,2),(9,1)

### .zipWithIndex ###

数组中的每个元素和它的索引组成一个新的数组

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