Scala--数组函数

++

定义：def ++[B](that: GenTraversableOnce[B]): Array[B]
描述：合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。

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

++:

定义：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
描述：与上个方法类似，但是该方法右边操纵数的类型决定着返回结果的类型。下面代码中List和LinkedList结合，返回结果是LinkedList类型

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

+:

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

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

:+

定义：def :+(elem: A): Array[A]
描述：同上面的方法想法，在数组末尾添加一个元素，并返回新对象

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

/:

定义：def /:[B](z: B)(op: (B, T) ⇒ B): B
描述：对数组中所有的元素进行相同的操作 ，foldLeft的简写，操作从右往左进行

val a = List(1,2,3,4)
// 将函数执行的每一步都输出
val c = (10/:a)((x,y)=>{println(x,y);x+y})

:\

定义：def :[B](z: B)(op: (T, B) ⇒ B): B
描述：对数组中所有的元素进行相同的操作，foldRight的简写，操作从左向右进行

val a = List(1,2,3,4)
val c = (a:\10)((x,y)=>{println(x,y);x+y})

注意：集合放置在冒号一侧

addString

定义：def addString(b: StringBuilder): StringBuilder
描述：将数组中的各个元素添加到StringBuilder中

val a =List(1,2,3,4)
// 无分隔符
val b = new StringBuilder
a.addString(b)
// 指定分隔符
val c = new StringBuilder
a.addString(c,"&")
// 指定分隔符，并在前后分别添加指定符号
val d = new StringBuilder
a.addString(d,"{","&","}")

aggregate

定义：def aggregate[B](z: => B)(seqop: (B, Int) => B,combop: (B, B) => B): B
描述：聚合计算，aggregate是柯里化方法，参数是两个方法

// 写法一
def seqop(x:Int,y:Int):Int={ // seqop用于分区内操作
println("seqop",x,y)
x+y
}
def combop(x:Int,y:Int):Int={ // combop用于分区间操作
println("combop",x,y)
x+y
}
// par相当于多线程或分片
a.par.aggregate(5)(seqop,combop)

// 写法二
a.par.aggregate(5)((x,y)=>{println("seqop",x,y);x+y},(x,y)=>{println("combop",x,y);x+y})

// 写法三
a.par.aggregate(5)(_+_,_+_)

apply

定义：def apply(i: Int): T
描述：取出指定索引处的元素；可以是数组，也可以是集合

val a = Array(1,2,3,4)
val c = a.apply(2) // c为3
// 等同于下列语句
val d = a(2)

canEqual

定义：def canEqual(that: Any): Boolean
描述：判断两个对象是否可以进行比较

val a = Array(1,2,3,4)
val b = Array(1,2,3)
val c = a.canEqual(b) // c:Boolean = True

charAt

定义：def charAt(index: Int): Char
描述：获取index索引处的字符，但类型必须为char类型

val chars = Array('a','b','c')
val c = chars.charAt(0) // c的值为a
val a = Array(1,2,3)
val c = a.charAt(0) // 报错

clone

定义：def clone(): Array[T]
描述：创建一个副本

val chars = Array('a','b','c')
val newchars = chars.clone() // c为Array[Char] = Array(a, b, c)
//  当原副本中包含对象时，clone拷贝的是对象的引用
var a = Array(1,2,3)
var b = Array(1,2,3,a)
var c=b.clone
a(1)=4
b
c

collect

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

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

collectFirst

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

val arr = Array("0",2,"a",'B')
val fun:PartialFunction[Any,Int]={
case x:Int => x*100
}
val a = arr.collectFirst(fun)
val b = arr.collectFirst({case x:Int => x*100})

combinations

定义：def combinations(n: Int): collection.Iterator[Array[T]]
描述：排列组合，排列组合会选出所有包含字符不一样的组合,不包括元素重复顺序不同，参数用于指定组合元素个数，返回的是迭代器

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

contains

定义：def contains[A1 >: A](elem: A1): Boolean
描述：数组中是否包含指定元素

val arr = Array("a","b","c","d")
arr.contains("a")
arr.contains("f")

containsSlice

定义：def containsSlice[B](that: GenSeq[B]): Boolean
描述：判断当前序列中是否包含另一个序列

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

copyToArray

定义：def copyToArray(xs: Array[A]): Unit
描述：拷贝内容到数组

val a = Array(1,2,3,4)
val b:Array[int] = new Array(6)
val c:Array[int] = new Array(6)
val d:Array[int] = new Array(6)
val e:Array[int] = new Array(6)
a.copyToArray(b) // b:Array[Int] = Array(1, 2, 3, 4, 0, 0)
// 指定插入位置，超出数组范围部分截掉
a.copyToArray(c,1) // c:Array[Int] = Array(0, 1, 2, 3, 4, 0)
a.copyToArray(d,3) // d:Array[Int] = Array(0, 0, 0, 1, 2, 3)
// 指定插入位置和插入长度
a.copyToArray(e,1,2) // e:Array[Int] = Array(0, 1, 2, 0, 0, 0)

copyToBuffer

定义：def copyToBuffer[B >: A](dest: Buffer[B]): Unit
描述：将数组中的内容拷贝到Buffer中

import scala.collection.mutable.ArrayBuffer
val a = Array(1,2,3,4)
val b:ArrayBuffer[Int]  = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(","))

corresponds

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

val a = Array(1,2,3)
val b = Array(4,5,6)
val c = Array(4,1,6)
val d = Array(4,5,6,7)
a.corresponds(b)(_<_)
a.corresponds(c)(_<_)
a.corresponds(d)(_<_)

count

定义：def count(p: (T) ⇒ Boolean): Int
描述：统计符合条件的元素个数，需要传递一个条件

val a = Array(1,2,3)
a.count(x=>x>1)
a.size // 用size计算长度

diff

定义：def diff(that: collection.Seq[T]): Array[T]
描述：计算当前数组与另一个数组的不同。

// 将当前数组中没有在另一个数组中出现的元素返回
val a = Array(1, 2, 3, 4)
val b = Array(4, 5, 6, 7)
val c = a.diff(b)

distinct

定义：def distinct: Array[T]
描述：去除当前集合中重复的元素，只保留一个

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

drop

定义：def drop(n: Int): Array[T]
描述：将当前序列中前 n 个元素去除后，作为一个新序列返回

val a = Array(1,1,2,2,3,3,4,4)
val c = a.drop(3)

dropRight

定义：def dropRight(n: Int): Array[T]
描述：去掉尾部的 n 个元素

val a = Array(1,1,2,2,3,3,4,4)
val c = a.dropRight(3)

dropWhile

定义：def dropWhile(p: (T) ⇒ Boolean): Array[T]
描述：去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

// 去除大于2的元素，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 2,3,4
val a = Array(3, 2, 3,4)
val b = a.dropWhile( {x:Int => x > 2} )

// 如果数组 a 是下面这样，第一个元素就不满足，所以返回整个数组 1, 2, 3,4
val a = Array(1, 2, 3,4) 

endsWith

定义：def endsWith[B](that: GenSeq[B]): Boolean
描述：判断是否以某个序列结尾，注意参数必须为序列，为单值会报错

val a = Array(1,2,3,4)
val b = Array(3,4)
a.endsWith(b)

exists

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

val a = Array(1,2,3,4)
a.exists(_==3)
a.exists(x=>x==2)
a.exists(_==5)

filter

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

val a = Array(1,2,3,4)
val c = a.filter(x=>x>2)

filterNot

定义：def filterNot(p: (T) ⇒ Boolean): Array[T]
描述：与 filter 的作用相反

val a = Array(1,2,3,4)
val c = a.filterNot(x=>x>2)

find

定义：override def find(p: Int => Boolean): Option[Int]
描述：查找第一个符合条件的元素

val a = Array(1, 2, 3, 4)
val b = a.find(x=>x>2) // b: Option[Int] = Some(3)

flatMap

定义：def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
描述：对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类

// 案例一
val a = Array(1,2,3,4)
val b = a.flatMap(1 to _)
// 案例二
val c = List("hello java","hello scala","hello hadoop")
val d = a.flatMap(x=>x.split(" "))

flatten

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

val a = Array(Array(1,2,3),Array(4,5,6))
val b = Array(Array("a","b","c"),Array("d","e","f"))
a.flatten
b.flatten

fold

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

val a = Array(1,2,3,4)
a.fold(5)(_+_)
a.fold(5)((x,y)=>{println(x,y);x+y})

foldLeft

定义：def foldLeft[B](z: B)(op: (B, T) ⇒ B): B
描述：从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) ⇒ B): B

val a = Array(1,2,3,4)
a.foldLeft(5)((x,y)=>{println(x,y);x+y})
// 简写
(5/:a)((x,y)=>{println(x,y);x+y})

foldRight

定义：def foldRight[B](z: B)(op: (B, T) ⇒ B): B
描述：从右到左计算，简写方式：def :[B](z: B)(op: (T, B) ⇒ B): B

val a = Array(1,2,3,4)
a.foldRight(5)((x,y)=>{println(x,y);x+y})
(a:\5)((x,y)=>{println(x,y);x+y})

forall

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

val a = Array(1,2,3,4)
val b = Array(1,2,3,4)
a.forall({x=>x>0})
b.forall({x=>x>1})

foreach

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

val a = Array(1,2,3,4)
a.foreach(x=>println(x>2))

groupBy

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

val a = Array(1,2,3,4)
val b = a.groupBy(x=>x)
val c = a.groupBy(x=>x match{
case x if(x<3) => "small"
case x if(x==3) => "equal"
case x if(x>3) => "big"
})
c.foreach(x=>println(x._1,x._2.toList))

grouped

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

val a = Array(1,2,3,4,5)
val b = a.grouped(2)
b.foreach(x=>println(x.mkString))

hasDefiniteSize

定义：def hasDefiniteSize: Boolean
描述：如果声明的集合的大小有限，则返回true，否则返回false，或者如果迭代器为空，则返回true，否则返回false。如果是流stream数据，则返回false

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

head

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

val a = Array(1,2,3,4,5)
a.head // 取第一个元素
a.tail // 取除第一个元素以外的其他元素

headOption

定义：def headOption: Option[T]
描述：返回Option类型对象，即Some 或者 None，如果序列是空，返回None

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

indexOf

定义：def indexOf(elem: T, from: Int): Int
描述：返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回

val a = Array(1,2,3,4,3,2,1)
a.indexOf(1)
// 指定查找位置
a.indexOf(3,3)

indexOfSlice

定义：def indexOfSlice[B >: A](that: GenSeq[B]): Int
描述：检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，若不匹配则返回-1

val a = Array(1,2,3,4,5,6)
val d = Array(3,4,5)
a.indexOfSlice(d)
// 指定查找开始位置
a.indexOfSlice(d,1)
a.indexOfSlice(d,3)

indexWhere

定义：def indexWhere(p: (T) ⇒ Boolean): Int
描述：返回当前序列中第一个满足 p 条件的元素的索引

val a = Array(1,2,3,4,5,6)
a.indexWhere(x=>x>3)
// 指定开始下标
a.indexWhere(x=>x>3,4)

indices

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

val a = Array(1,2,3,4,5,6)
a.indices

init

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

val a = Array(1,2,3,4,5,6)
a.init

inits

定义：def inits: collection.Iterator[Array[T]]
描述：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象

val a = Array(1,2,3,4,5,6)
a.inits.toList

intersect

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

val a = Array(1,2,3,4,5,6)
val b = Array(2,4,8)
a.intersect(b)

isDefinedAt

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

val a = Array(1,2,3,4,5,6)
a.isDefinedAt(1)
a.isDefinedAt(7)

isEmpty

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

val a = Array(1,2,3,4,5,6)
val b:Array[Int] = Array[Int]()
a.isEmpty
b.isEmpty

isTraversableAgain

定义：def isTraversableAgain: Boolean
描述：判断序列是否可以反复遍历，对于 Iterators返回 false

val a = Array(1,2,3,4,5,6)
a.isTraversableAgain 

iterator

定义：def iterator: collection.Iterator[T]
描述：对序列中的每个元素产生一个 iterator

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

last

定义：def last: T
描述：取得序列中最后一个元素

val a = Array(1,2,3,4,5,6)
a.last

lastIndexOf

定义：def lastIndexOf(elem: T): Int
描述：取得序列中最后一个等于 elem 的元素的位置

val a = Array(1,2,3,1,2,3,5,6,7,8,3)
a.indexOf(3)
a.lastIndexOf(3)
// 指定查找结束的位置（下标）
a.lastIndexOf(3,8)

lastIndexOfSlice

定义：def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
描述：判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引

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

lastIndexWhere

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

val a = Array(1,2,3,4,5,6,7)
a.lastIndexWhere(x=>x<5)
// 指定结束的下标
a.lastIndexWhere(x=>x<5,2)

lastOption

定义：def lastOption: Option[T]
描述：返回当前序列中最后一个对象

val a = Array(1,2,3,1,2,3)
val b = Array(Array(1,2),Array(3,4),Array(5,6))
a.lastOption
b.lastOption

length

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

val a = Array(1,2,3,1,2,3)
a.length

IengthCompare

定义：def lengthCompare(len: Int): Int
描述：比较序列的长度和参数 len，根据二者的关系返回不同的值

val a = Array(1,2,3,1,2,3)
a.length
a.lengthCompare(6)  // 6-6
a.lengthCompare(9)  // 6-9
a.lengthCompare(3)  // 6-3

map

定义：def map[B](f: (A) ⇒ B): Array[B]
描述：对序列中的元素进行 f 操作

val a = Array(1,2,3,4,5,6)
a.map(x=>(x,1))
a.map(x=>x+1)

max

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

val a = Array(1,2,3,1,2,3)
a.max

maxBy

定义：def maxBy[B](f: (A) ⇒ B): A
描述：返回序列中第一个符合条件的最大的元素，当都不满足是返回第一个元素

val a = Array(1,2,3,1,2,3)
a.maxBy(_>2)  
a.maxBy(_>1)
a.maxBy(_>3)

min

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

val a = Array(1,2,3,1,2,3)
a.min

minBy

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

val a = Array(1,2,3,1,2,3)
a.minBy(x=>x<2)
a.minBy(x=>x<1)

mkString

定义：def mkString: String
描述：将所有元素组合成一个字符串

val a = Array(1,2,3,4)
a.mkString
// 指定分隔符
a.mkString(",")
// 指定分隔符，并在首尾添加指定符号
a.mkString("{",",","}")

nonEmpty

定义：def nonEmpty: Boolean
描述：判断序列不为空，不为空返回true，反之返回false

val a = Array(1,2,3,4)
val b:Array[Int] = Array[Int]()
a.nonEmpty
b.nonEmpty

padTo

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

val a = Array(1,2,3,4)
a.padTo(6,5)
a.padTo(4,5)

par

定义：def par: ParArray[T]
描述：返回一个并行实现，即并行实现要执行的方法，产生的并行序列，不能被修改

val a = Array(1,2,3,4,5)
a.foreach(println)
a.par.foreach(println)

partition

定义：def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
描述：按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列

val a = Array(1,2,3,4,5)
a.partition(x=>x%3==1)

patch

定义：def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
描述：批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that

val a = Array(1,2,3,4,5,6,7,8)
val b =  Array(11,12,13)
a.patch(3,b,1)
a.patch(3,b,2)
a.patch(3,b,6)

permutations

定义：def permutations: collection.Iterator[Array[T]]
描述：排列组合，组合中的内容可以相同，但是顺序不能相同，在这点与combinations有所区别

val a = Array(1,2,3)
a.permutations.toList
a.combinations(3).toList

prefixLength

定义：def prefixLength(p: (T) ⇒ Boolean): Int
描述：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p

val a = Array(1,2,4,8,6,5,4)
a.prefixLength(x=>x<5) // 1 2 4满足条件，故返回3

product

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

val a = Array(1,2,3,4,5)
a.product

reduce

定义：def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
描述：与 fold相似，不需要初始值

val a = Array(1,2,3,4,5)
a.reduce((x,y)=>{println(x,y);x+y})
a.fold(5)((x,y)=>{println(x,y);x+y})
a.reduce(_+_)
a.fold(5)(_+_)

reduceLeft

定义：def reduceLeft[B >: A](op: (B, T) ⇒ B): B
描述：同reduce,从左向右计算

val a = Array(1,2,3,4,5)
a.reduceLeft((x,y)=>{println(x,y);x+y})

reduceRight

定义：def reduceRight[B >: A](op: (T, B) ⇒ B): B
描述：从右向左计算

val a = Array(1,2,3,4,5)
a.reduceRight((x,y)=>{println(x,y);x+y})

reduceLeftOption

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

val a = Array(1,2,3,4,5)
a.reduceLeftOption(_+_)

reduceRightOption

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

val a = Array(1,2,3,4,5)
a.reduceRightOption(_+_)

reverse

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

val a = Array(1,2,3,4,5)
a.reverse

reverseIterator

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

val a = Array(1,2,3,4,5)
a.reverseIterator
a.reverseIterator.foreach(println)

reverseMap

定义：def reverseMap[B](f: (A) ⇒ B): Array[B]
描述：同 map，序列的顺序倒置

val a = Array(1,2,3,4,5)
a.reverseMap(x=>x*10)
a.reverseMap(_*10)

sameElements

定义：def sameElements(that: GenIterable[A]): Boolean
描述：判断两个序列是否顺序和对应位置上的元素都一样，且两个序列的长度必须一致，否则结果为false

val a = Array(1,2,3,4,5)
val b = Array(1,2,3,4,5)
val c = Array(1,2,3,4,5,6)
a.sameElements(b)
a.sameElements(c)

scan

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

val a = Array(1,2,3,4,5)
a.scan(9)((x,y)=>{println(x,y);x+y})
a.scan(9)(_+_)
a.fold(9)(_+_)

scanLeft

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

val a = Array(1,2,3,4,5)
a.scanLeft(9)((x,y)=>{println(x,y);x+y})

scanRight

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

val a = Array(1,2,3,4,5)
a.scanRight(9)((x,y)=>{println(x,y);x+y})

segmentLength

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

val a = Array(1,2,3,4,5,6)
a.segmentLength(x=>{x<5},0)
a.segmentLength(x=>{x<5},2)

seq

定义：def seq: collection.mutable.IndexedSeq[T]
描述：产生一个引用当前序列的 sequential 视图

val a = Array(1,2,3,4,5,6)
a.seq
a.seq.foreach(println)

size

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

val a = Array(1,2,3,4,5,6)
a.size
a.length

slice

定义：def slice(from: Int, until: Int): Array[T]
描述：取出当前序列中，from 到 until 之间的片段

val a = Array(1,2,3,4)
a.slice(1,3)
a.slice(0,5)

sliding

定义：def sliding(size: Int): collection.Iterator[Array[T]]
描述：按照顺序从左向右一个一个滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组(数组长度为3)，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束

val a = Array(1,2,3,4,5,6,7,8,9,10)
a.sliding(3).toList
// 第二个参数为步长
a.sliding(3,3).toList

sortBy

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

val a = Array(1,2,3,4,5,6,7,8,9,10)
a.sortBy(x=>x)
a.sortBy(x=>{-x}) // 倒序

sortWith

定义：def sortWith(lt: (T, T) ⇒ Boolean): Array[T]
描述：自定义排序方法 对序列排序

val a = Array(1,2,3,4,5,6,7,8,9,10)
a.sortWith((x,y)=>{println(x,y);x.compareTo(y)>0}) // 逆序
a.sortWith((x,y)=>{x.compareTo(y)<0}) // 正序

sorted

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

val a = Array(("hello",4),("world",1),("scala",3),("java",6))
val b = Array(5,4,3,2,1)
a.sorted
b.sorted

span

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

val a = Array(1,2,4,3,5)
a.span(x=>x<4)

splitAt

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

val a = Array(1,2,3,4,5,6,7,8,9,10)
a.splitAt(5)

startsWith

定义：def startsWith[B](that: GenSeq[B]): Boolean
描述：判断序列是否以某个序列开始

val a = Array(1,2,3,4,5,6,7,8,9,10)
val b = Array(6,7,8)
a.startsWith(b)
// 指定开始的位置
a.startsWith(b,5)

stringPrefix

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

val a = Array(1,2,3,4,5,6,7,8,9,10)
val b = List(1,2,3,4)
a.toString
a.stringPrefix
b.toString
b.stringPrefix

subSequence

定义：def subSequence(start: Int, end: Int): CharSequence
描述：返回 start 和 end 间的字符序列，不包含 end 处的元素,只适用于字符数组)

val a = Array('a','b','c','d','e')
val b = Array(1,2,3,4)
a.subSequence(0,2)
b.subSequence(0,2)

sum

定义：def sum: A
描述：序列求和

val a = Array(1,2,3,4,5,6,7,8,9,10)
a.sum

tail

定义：def tail: Array[T]
描述：返回当前序列中不包含第一个元素的序列；与init相反，init去除最后一个元素

val a = Array(1,2,3,4,5,6,7,8,9,10)
a.tail

tails

定义：def tails: collection.Iterator[Array[T]]
描述：同 inits，每一步都进行 tail 操作，直到null为止，并返回每一步tail操作的数组，最终返回一个集合

val a = Array(1,2,3,4)
a.tails.toList
a.inits.toList

take

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

val a = Array(1,2,3,4,5,6,7,8,9,10)
a.take(2)
a.take(5)

takeRight

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

val a = Array(1,2,3,4,5,6,7,8,9,10)
a.takeRight(2)
a.takeRight(5)

takeWhile

定义：def takeWhile(p: (T) ⇒ Boolean): Array[T]
描述：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列

val a = Array(1,2,3,4,5,8,7,8,9,10)
a.takeWhile(x=>x<8)

toArray

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

val a = List(1,2,3,4,5)
val b = "hello"
a.toArray
b.toArray

toBuffer

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

val a = List(1,2,3,4,5)
val b = "hello"
a.toBuffer
b.toBuffer

toIndexedSeq

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

val a = List(1,2,3,4,5)
val b = "hello"
a.toIndexedSeq
b.toIndexedSeq

toIterable

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

val a = List(1,2,3,4,5)
a.toIterable.foreach(println)

toIterator

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

val a = List(1,2,3,4,5)
a.toIterator

toList

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

val a = Array(1,2,3,4,5)
a.toList

toMap

定义：def toMap[T, U]: Map[T, U]
描述：将序列转转换成 Map 类型,被转换的元素必须是元组

val a = Array(1,2,3,4,5)
a.map((_,1)).toMap

toSeq

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

val a = Array(3,2,1,5,4)
a.toSeq

toSet

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

val a = Array(3,2,1,5,4)
a.toSet

toStream

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

val a = Array(1,2,3,4,5)
a.toStream
a.toStream(1)
a.toStream(2)
a.toStream(0)

toVector

定义：def toVector: Vector[T]
描述：将序列转换成 Vector 类型

val a = Array(1,2,3,4,5,6)
a.toVector

transpose

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

val  a = Array(Array("a","b"),Array("c","d"),Array("e","f"),Array("g","h"))
a.transpose.foreach(x=>println(x.toList))

union

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

val a = Array(1,2,3)
val b = Array(4,5,6)
a.union(b)

unzip

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

val a = Array(("a","b"),("c","d"))
a.unzip

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])
描述：将含有若干个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组

val a = Array(("a","b","c"),("d","e","f"),("g","h","i"))
a.unzip3

update

定义：def update(i: Int, x: T): Unit
描述：将序列中 i 索引处的元素更新为 x,改变的是序列本身

val a = Array(5,4,3,2,1,0,9)
a.update(5,6)
a

updated

定义：def updated(index: Int, elem: A): Array[A]
描述：将序列中 i 索引处的元素更新为 x，并返回替换后的数组

val a = Array(5,4,3,2,1,0,9)
a.updated(5,6)

view

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

val a = Array(5,4,3,2,1,0,9)
a.view(1,3)
a.view(1,3).toList

withFilter

定义：def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
描述：根据条件 p 过滤元素

val a = Array(1,2,3,4,5)
a.withFilter(x=>x>2)
a.withFilter(x=>x>2).map(x=>x)

zip

定义：def zip[B](that: GenIterable[B]): Array[(A, B)]
描述：将两个序列对应位置上的元素组成一个元组数组，若两个序列长度不相同，短的序列结束则停止

val a = Array(1,2,3,4,5)
val b = Array(6,7,8,9,10)
val c = Array(11,12,13,14,15,16,17,18)
a.zip(b)
a.zip(c)

zipAll

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

val a = Array(1,2,3,4,5,100)
val b = Array(6,7,8,9,10)
val c = Array(11,12,13,14,15,16,17,18)
a.zipAll(b,200,300)
a.zipAll(c,200,300)

zipWithIndex

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

val a = Array(1,2,3,4,5)
a.zipWithIndex