數(shù)組是一種可變的、可索引的數(shù)據(jù)集合斑匪。在Scala中用Array[T]的形式來表示Java中的數(shù)組形式 T[]。

valnumbers =Array(1,2,3,4)//聲明一個(gè)數(shù)組對(duì)象valfirst = numbers(0)// 讀取第一個(gè)元素numbers(3) =100// 替換第四個(gè)元素為100valbiggerNumbers = numbers.map(_ *2)// 所有元素乘2

Scala提供了大量的集合操作：

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

合并集合白热，并返回一個(gè)新的數(shù)組搀崭，新數(shù)組包含左右兩個(gè)集合對(duì)象的內(nèi)容佑稠。

vala =Array(1,2)valb =Array(3,4)valc = a ++ b//c中的內(nèi)容是(1,2,3,4)

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

這個(gè)方法同上一個(gè)方法類似秒梅，兩個(gè)加號(hào)后面多了一個(gè)冒號(hào)，但是不同的是右邊操縱數(shù)的類型決定著返回結(jié)果的類型舌胶。下面代碼中List和LinkedList結(jié)合捆蜀，返回結(jié)果是LinkedList類型

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

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

在數(shù)組前面添加一個(gè)元素，并返回新的對(duì)象，下面添加一個(gè)元素 0

vala = List(1,2)valc =0+: a// c中的內(nèi)容是 （0,1,2）

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

同上面的方法想法辆它，在數(shù)組末尾添加一個(gè)元素誊薄，并返回新對(duì)象

def /:[B](z: B)(op: (B, T) ?6?0 B): B

對(duì)數(shù)組中所有的元素進(jìn)行相同的操作 ，foldLeft的簡(jiǎn)寫

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

def :\[B](z: B)(op: (T, B) ?6?0 B): B

foldRight的簡(jiǎn)寫

def addString(b: StringBuilder): StringBuilder

將數(shù)組中的元素逐個(gè)添加到b中

vala = List(1,2,3,4)valb =newStringBuilder()valc = a.addString(b)// c中的內(nèi)容是? 1234

def addString(b: StringBuilder, sep: String): StringBuilder

同上锰茉，每個(gè)元素用sep分隔符分開

vala = List(1,2,3,4)valb =newStringBuilder()valc = a.addString(b,",")? ? println("c:? "+c)// c:? 1,2,3,4

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

同上呢蔫，在首尾各加一個(gè)字符串，并指定sep分隔符

vala = List(1,2,3,4)valb =newStringBuilder()valc = a.addString(b,"{",",","}")? ? println("c:? "+c)// c:? {1,2,3,4}

def aggregate[B](z: ?6?0 B)(seqop: (B, T) ?6?0 B, combop: (B, B) ?6?0 B): B

聚合計(jì)算飒筑，aggregate是柯里化方法咐刨，參數(shù)是兩個(gè)方法，為了方便理解扬霜，我們把a(bǔ)ggregate的兩個(gè)參數(shù)，分別封裝成兩個(gè)方法而涉，并把計(jì)算過程打印出來著瓶。

defmain(args:Array[String]) {vala = List(1,2,3,4)valc = a.par.aggregate(5)(seqno,combine)? ? println("c:"+c)? }defseqno(m:Int,n:Int): Int ={vals ="seq_exp=%d+%d"println(s.format(m,n))returnm+n? }defcombine(m:Int,n:Int): Int ={vals ="com_exp=%d+%d"println(s.format(m,n))returnm+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

*/

上面過程可以簡(jiǎn)寫為

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

def apply(i: Int): T

同下面代碼，取出指定索引處的元素

valfirst = numbers(0)// 讀取第一個(gè)元素

def canEqual(that: Any): Boolean

判斷兩個(gè)對(duì)象是否可以進(jìn)行比較

def charAt(index: Int): Char

獲取index索引處的字符啼县，這個(gè)方法會(huì)執(zhí)行一個(gè)隱式的轉(zhuǎn)換材原，將Array[T]轉(zhuǎn)換為 ArrayCharSequence，只有當(dāng)T為char類型時(shí)季眷，這個(gè)轉(zhuǎn)換才會(huì)發(fā)生余蟹。

valchars=Array('a','b','c')println("c:"+chars.charAt(0))//結(jié)果 a

def clone():Array[T]

創(chuàng)建一個(gè)副本

valchars=Array('a','b','c')? ? println(a.apply(2))? ? val newchars =chars.clone()

def collect[B](pf: PartialFunction[A, B]):Array[B]

通過執(zhí)行一個(gè)并行計(jì)算（偏函數(shù)），得到一個(gè)新的數(shù)組對(duì)象

valchars =Array('a','b','c')valnewchars = chars.collect(fun)? println("newchars:"+newchars.mkString(","))//我們通過下面的偏函數(shù)子刮，把chars數(shù)組的小寫a轉(zhuǎn)換為大寫的Avalfun:PartialFunction[Char,Char] = {case'a'=>'A'casex => x? }/**輸出結(jié)果是 newchars:A,b,c */

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

在序列中查找第一個(gè)符合偏函數(shù)定義的元素威酒，并執(zhí)行偏函數(shù)計(jì)算

valarr =Array(1,'a',"b")//定義一個(gè)偏函數(shù)，要求當(dāng)被執(zhí)行對(duì)象為Int類型時(shí)挺峡，進(jìn)行乘100的操作葵孤，對(duì)于上面定義的對(duì)象arr來說，只有第一個(gè)元素符合要求valfun:PartialFunction[Any,Int] = {? ? case x:Int => x*100}//計(jì)算valvalue = arr.collectFirst(fun)? println("value:"+value)//另一種寫法valvalue = arr.collectFirst({case x:Int => x*100})

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

排列組合橱赠，這個(gè)排列組合會(huì)選出所有包含字符不一樣的組合尤仍，對(duì)于 “abc”、“cba”狭姨，只選擇一個(gè)宰啦，參數(shù)n表示序列長(zhǎng)度，就是幾個(gè)字符為一組

valarr =Array("a","b","c")valnewarr = arr.combinations(2)? ? newarr.foreach((item) => println(item.mkString(",")))/**

a,b

a,c

b,c

*/

def contains[A1 >: A](elem: A1): Boolean

序列中是否包含指定對(duì)象

def containsSlice[B](that: GenSeq[B]): Boolean

判斷當(dāng)前序列中是否包含另一個(gè)序列

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

def copyToArray(xs:Array[A]): Unit

此方法還有兩個(gè)類似的方法饼拍，將數(shù)組拷貝到另一個(gè)數(shù)組 超過部分截?cái)?不夠的話 默認(rèn)填充

將指定部分的數(shù)組內(nèi)容拷貝到 xs 中 取余部分仍然保留xs原有的數(shù)據(jù) 如果xs沒有被初始化 默認(rèn)以默認(rèn)值填充

copyToArray(xs:Array[A], start: Int): Unit

vala =Array('a','b','c')valb :Array[Char] =newArray(5)a.copyToArray(b)/**b中元素 ['a','b','c',0,0]*/a.copyToArray(b,1)/**b中元素 [0,'a',0,0,0]*/a.copyToArray(b,1,2)/**b中元素 [0,'a','b',0,0]*/

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

將數(shù)組中的內(nèi)容拷貝到Buffer中

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

def corresponds[B](that: GenSeq[B])(p: (T, B) ?6?0 Boolean): Boolean

判斷兩個(gè)序列長(zhǎng)度以及對(duì)應(yīng)位置元素是否符合某個(gè)條件赡模。如果兩個(gè)序列具有相同的元素?cái)?shù)量并且p(x, y)=true，返回結(jié)果為true

下面代碼檢查a和b長(zhǎng)度是否相等惕耕，并且a中元素是否小于b中對(duì)應(yīng)位置的元素

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

def count(p: (T) ?6?0 Boolean): Int

統(tǒng)計(jì)符合條件的元素個(gè)數(shù)纺裁，下面統(tǒng)計(jì)大于 2 的元素個(gè)數(shù)

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

def diff(that: collection.Seq[T]):Array[T]

計(jì)算當(dāng)前數(shù)組與另一個(gè)數(shù)組的不同。將當(dāng)前數(shù)組中有在另一個(gè)數(shù)組中沒有出現(xiàn)的元素返回

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

def distinct:Array[T]

去除當(dāng)前集合中重復(fù)的元素，只保留一個(gè)

vala =Array(1,2,3,4,4,5,6,6)valc = a.distinctprintln(c.mkString(","))// 1,2,3,4,5,6

def drop(n: Int):Array[T]

將當(dāng)前序列中前 n 個(gè)元素去除后欺缘，作為一個(gè)新序列返回

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

def dropRight(n: Int):Array[T]

功能同 drop栋豫，去掉尾部的 n 個(gè)元素

def dropWhile(p: (T) ?6?0 Boolean):Array[T]

去除當(dāng)前數(shù)組中符合條件的元素，這個(gè)需要一個(gè)條件谚殊，就是從當(dāng)前數(shù)組的第一個(gè)元素起丧鸯，就要滿足條件，直到碰到第一個(gè)不滿足條件的元素結(jié)束（即使后面還有符合條件的元素）嫩絮，否則返回整個(gè)數(shù)組

//下面去除大于2的丛肢，第一個(gè)元素 3 滿足，它后面的元素 2 不滿足剿干，所以返回 2,3,4vala =Array(3,2,3,4)valc = a.dropWhile( {x:Int => x >2} )println(c.mkString(","))//如果數(shù)組 a 是下面這樣蜂怎，第一個(gè)元素就不滿足，所以返回整個(gè)數(shù)組 1, 2, 3,4vala =Array(1,2,3,4)

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

判斷是否以某個(gè)序列結(jié)尾

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

def exists(p: (T) ?6?0 Boolean): Boolean

判斷當(dāng)前數(shù)組是否包含符合條件的元素

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

def filter(p: (T) ?6?0 Boolean):Array[T]

取得當(dāng)前數(shù)組中符合條件的元素置尔，組成新的數(shù)組返回

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

def filterNot(p: (T) ?6?0 Boolean):Array[T]

與上面的 filter 作用相反

def find(p: (T) ?6?0 Boolean): Option[T]

查找第一個(gè)符合條件的元素

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

def flatMap[B](f: (A) ?6?0 GenTraversableOnce[B]):Array[B]

對(duì)當(dāng)前序列的每個(gè)元素進(jìn)行操作杠步，結(jié)果放入新序列返回，參數(shù)要求是GenTraversableOnce及其子類

vala =Array(1,2,3,4)valb = a.flatMap(x=>1to x)println(b.mkString(","))/**

1,1,2,1,2,3,1,2,3,4

從1開始榜轿，分別于集合a的每個(gè)元素生成一個(gè)遞增序列幽歼，過程如下

1

1,2

1,2,3

1,2,3,4

*/

def flatten[U](implicit asTrav: (T) ?6?0 collection.Traversable[U], m: ClassTag[U]):Array[U]

將二維數(shù)組的所有元素聯(lián)合在一起，形成一個(gè)一維數(shù)組返回

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

-def fold[A1 >: A](z: A1)(op: (A1, A1) ?6?0 A1): A1

對(duì)序列中的每個(gè)元素進(jìn)行二元運(yùn)算谬盐，和aggregate有類似的語義甸私，但執(zhí)行過程有所不同，我們來對(duì)比一下他們的執(zhí)行過程飞傀。

因?yàn)閍ggregate需要兩個(gè)處理方法皇型，所以我們定義一個(gè)combine方法

defseqno(m:Int,n:Int): Int ={vals ="seq_exp=%d+%d"println(s.format(m,n))returnm+n? }defcombine(m:Int,n:Int): Int ={vals ="com_exp=%d+%d"println(s.format(m,n))returnm+n? }vala =Array(1,2,3,4)valb = a.fold(5)(seqno)/** 運(yùn)算過程

seq_exp=5+1

seq_exp=6+2

seq_exp=8+3

seq_exp=11+4

*/valc = a.par.aggregate(5)(seqno,combine)/** 運(yùn)算過程

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

*/

看上面的運(yùn)算過程發(fā)現(xiàn)，fold中助析，seqno是把初始值順序和每個(gè)元素相加犀被，把得到的結(jié)果與下一個(gè)元素進(jìn)行運(yùn)算

而aggregate中，seqno是把初始值與每個(gè)元素相加外冀，但結(jié)果不參與下一步運(yùn)算寡键，而是放到另一個(gè)序列中，由第二個(gè)方法combine進(jìn)行處理

-def foldLeft[B](z: B)(op: (B, T) ?6?0 B): B

從左到右計(jì)算雪隧，簡(jiǎn)寫方式：def /:[B](z: B)(op: (B, T) ?6?0 B): B

defseqno(m:Int,n:Int): Int ={vals ="seq_exp=%d+%d"println(s.format(m,n))returnm+n? }vala =Array(1,2,3,4)valb = a.foldLeft(5)(seqno)/** 運(yùn)算過程

seq_exp=5+1

seq_exp=6+2

seq_exp=8+3

seq_exp=11+4

*//**

簡(jiǎn)寫 (5 /: a)(_+_)

*/

-def foldRight[B](z: B)(op: (B, T) ?6?0 B): B

從右到左計(jì)算西轩，簡(jiǎn)寫方式：def :\[B](z: B)(op: (T, B) ?6?0 B): B

defseqno(m:Int,n:Int): Int ={vals ="seq_exp=%d+%d"println(s.format(m,n))returnm+n? }vala =Array(1,2,3,4)valb = a.foldRight(5)(seqno)/** 運(yùn)算過程

seq_exp=4+5

seq_exp=3+9

seq_exp=2+12

seq_exp=1+14

*//**

簡(jiǎn)寫 (a :\ 5)(_+_)

*/

-def forall(p: (T) ?6?0 Boolean): Boolean

檢測(cè)序列中的元素是否都滿足條件 p，如果序列為空脑沿，返回true

vala =Array(1,2,3,4)valb = a.forall( {x:Int => x>0})//truevalb = a.forall( {x:Int => x>2})//false

-def foreach(f: (A) ?6?0 Unit): Unit

檢測(cè)序列中的元素是否都滿足條件 p藕畔，如果序列為空，返回true

vala =Array(1,2,3,4)valb = a.forall( {x:Int => x>0})//truevalb = a.forall( {x:Int => x>2})//false

-def foreach(f: (A) ?6?0 Unit): Unit

遍歷序列中的元素庄拇，進(jìn)行 f 操作

vala =Array(1,2,3,4)? ? a.foreach(x => println(x*10))/**

10

20

30

40

*/

-def groupBy[K](f: (T) ?6?0 K): Map[K,Array[T]]

按條件分組注服，條件由 f 匹配韭邓，返回值是Map類型，每個(gè)key對(duì)應(yīng)一個(gè)序列溶弟，下面代碼實(shí)現(xiàn)的是女淑，把小于3的數(shù)字放到一組，大于3的放到一組辜御，返回Map[String,Array[Int]]

val a =Array(1,2,3,4)? ? val b = a.groupBy( x=>x match {casexif(x <3)=>"small"case_=>"big"})

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

按指定數(shù)量分組鸭你，每組有 size 數(shù)量個(gè)元素，返回一個(gè)集合

vala =Array(1,2,3,4,5)valb = a.grouped(3).toListb.foreach((x) => println("第"+(b.indexOf(x)+1)+"組:"+x.mkString(",")))/**

第1組:1,2,3

第2組:4,5

*/

-def hasDefiniteSize: Boolean

檢測(cè)序列是否存在有限的長(zhǎng)度擒权，對(duì)應(yīng)Stream這樣的流數(shù)據(jù)袱巨，返回false

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

-def head: T

返回序列的第一個(gè)元素，如果序列為空碳抄，將引發(fā)錯(cuò)誤

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

-def headOption: Option[T]

返回Option類型對(duì)象愉老，就是scala.Some 或者 None，如果序列是空剖效，返回None

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

-def indexOf(elem: T): Int

返回elem在序列中的索引俺夕，找到第一個(gè)就返回

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

-def indexOf(elem: T, from: Int): Int

返回elem在序列中的索引，可以指定從某個(gè)索引處（from）開始查找贱鄙，找到第一個(gè)就返回

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

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

檢測(cè)當(dāng)前序列中是否包含另一個(gè)序列（that），并返回第一個(gè)匹配出現(xiàn)的元素的索引

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

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

檢測(cè)當(dāng)前序列中是否包含另一個(gè)序列（that）姨谷，并返回第一個(gè)匹配出現(xiàn)的元素的索引逗宁，指定從 from 索引處開始

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

-def indexWhere(p: (T) ?6?0 Boolean): Int

返回當(dāng)前序列中第一個(gè)滿足 p 條件的元素的索引

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

-def indexWhere(p: (T) ?6?0 Boolean, from: Int): Int

返回當(dāng)前序列中第一個(gè)滿足 p 條件的元素的索引，可以指定從 from 索引處開始

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

-def indices: collection.immutable.Range

返回當(dāng)前序列索引集合

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

-def init:Array[T]

返回當(dāng)前序列中不包含最后一個(gè)元素的序列

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

-def inits: collection.Iterator[Array[T]]

對(duì)集合中的元素進(jìn)行 init 操作梦湘，該操作的返回值中瞎颗， 第一個(gè)值是當(dāng)前序列的副本，包含當(dāng)前序列所有的元素捌议，最后一個(gè)值是空的哼拔，對(duì)頭尾之間的值進(jìn)行init操作，上一步的結(jié)果作為下一步的操作對(duì)象

vala =Array(1,2,3,4,5)valb = a.inits.toListfor(i <-1to b.length){vals ="第%d個(gè)值：%s"println(s.format(i,b(i-1).mkString(",")))? ? }/**計(jì)算結(jié)果

第1個(gè)值：1,2,3,4,5

第2個(gè)值：1,2,3,4

第3個(gè)值：1,2,3

第4個(gè)值：1,2

第5個(gè)值：1

第6個(gè)值

*/

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

取兩個(gè)集合的交集

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

-def isDefinedAt(idx: Int): Boolean

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

vala=Array(1,2,3,4,5)? ? println(a.isDefinedAt(1))// trueprintln(a.isDefinedAt(10))// false

-def isEmpty: Boolean

判斷當(dāng)前序列是否為空

-def isTraversableAgain: Boolean

判斷序列是否可以反復(fù)遍歷瓣颅，該方法是GenTraversableOnce中的方法倦逐，對(duì)于 Traversables 一般返回true，對(duì)于 Iterators 返回 false宫补，除非被復(fù)寫

-def iterator: collection.Iterator[T]

對(duì)序列中的每個(gè)元素產(chǎn)生一個(gè) iterator

vala =Array(1,2,3,4,5)valb = a.iterator//此時(shí)就可以通過迭代器訪問 b

-def last: T

取得序列中最后一個(gè)元素

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

-def lastIndexOf(elem: T): Int

取得序列中最后一個(gè)等于 elem 的元素的位置

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

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

取得序列中最后一個(gè)等于 elem 的元素的位置檬姥，可以指定在 end 之前（包括）的元素中查找

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

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

判斷當(dāng)前序列中是否包含序列 that，并返回最后一次出現(xiàn)該序列的位置處的索引

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

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

判斷當(dāng)前序列中是否包含序列 that粉怕，并返回最后一次出現(xiàn)該序列的位置處的索引健民，可以指定在 end 之前（包括）的元素中查找

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

-def lastIndexWhere(p: (T) ?6?0 Boolean): Int

返回當(dāng)前序列中最后一個(gè)滿足條件 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

-def lastIndexWhere(p: (T) ?6?0 Boolean, end: Int): Int

返回當(dāng)前序列中最后一個(gè)滿足條件 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

-def lastOption: Option[T]

返回當(dāng)前序列中最后一個(gè)對(duì)象

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

-deflength: Int

返回當(dāng)前序列中元素個(gè)數(shù)

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

-def lengthCompare(len: Int): Int

比較序列的長(zhǎng)度和參數(shù) len贫贝，根據(jù)二者的關(guān)系返回不同的值秉犹，比較規(guī)則是

x <0ifthis.lengthlength==lenx >0ifthis.length>len

-def map[B](f: (A) ?6?0 B):Array[B]

對(duì)序列中的元素進(jìn)行 f 操作

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

-def max: A

返回序列中最大的元素

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

-def maxBy[B](f: (A) ?6?0 B): A

返回序列中第一個(gè)符合條件的最大的元素

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

-def mkString: String

將所有元素組合成一個(gè)字符串

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

-def mkString(sep: String): String

將所有元素組合成一個(gè)字符串蛉谜，以 sep 作為元素間的分隔符

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

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

將所有元素組合成一個(gè)字符串，以 start 開頭崇堵，以 sep 作為元素間的分隔符型诚，以 end 結(jié)尾

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

-def nonEmpty: Boolean

判斷序列不是空

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

后補(bǔ)齊序列，如果當(dāng)前序列長(zhǎng)度小于 len筑辨，那么新產(chǎn)生的序列長(zhǎng)度是 len俺驶，多出的幾個(gè)位值填充 elem，如果當(dāng)前序列大于等于 len 棍辕，則返回當(dāng)前序列

vala =Array(1,2,3,4,5)valb = a.padTo(7,9)//需要一個(gè)長(zhǎng)度為 7? 的新序列暮现，空出的填充 9println(b.mkString(","))// return? 1,2,3,4,5,9,9

-def par: ParArray[T]

返回一個(gè)并行實(shí)現(xiàn)，產(chǎn)生的并行序列楚昭，不能被修改

vala =Array(1,2,3,4,5)valb = a.par//? "ParArray" size = 5

-def partition(p: (T) ?6?0 Boolean): (Array[T],Array[T])

按條件將序列拆分成兩個(gè)新的序列栖袋，滿足條件的放到第一個(gè)序列中，其余的放到第二個(gè)序列抚太，下面以序列元素是否是 2 的倍數(shù)來拆分

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,4println(b._2.mkString(","))// return? 1,3,5

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

批量替換山上，從原序列的 from 處開始，后面的 replaced 數(shù)量個(gè)元素俄认，將被替換成序列 that

vala =Array(1,2,3,4,5)valb =Array(3,4,6)valc = a.patch(1,b,2)? ? println(c.mkString(","))// return 1,3,4,6,4,5/**從 a 的第二個(gè)元素開始蒂阱，取兩個(gè)元素，即 2和3 庆亡，這兩個(gè)元素被替換為 b的內(nèi)容*/

-def permutations: collection.Iterator[Array[T]]

排列組合匾乓，他與combinations不同的是，組合中的內(nèi)容可以相同又谋，但是順序不能相同拼缝，combinations不允許包含的內(nèi)容相同，即使順序不一樣

vala =Array(1,2,3,4,5)valb = a.permutations.toList// b 中將有120個(gè)結(jié)果彰亥，知道排列組合公式的咧七，應(yīng)該不難理解吧/**如果是combinations*/valb = a.combinations(5).toList// b 中只有一個(gè)，因?yàn)椴还茉鯓优帕腥握际沁@5個(gè)數(shù)字組成继阻，所以只能保留第一個(gè)

-def prefixLength(p: (T) ?6?0 Boolean): Int

給定一個(gè)條件 p，返回一個(gè)前置數(shù)列的長(zhǎng)度废酷，這個(gè)數(shù)列中的元素都滿足 p[沒看懂]

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

-def product: A

返回所有元素乘積的值

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

-def reduce[A1 >: A](op: (A1, A1) ?6?0 A1): A1

同 fold穴翩，不需要初始值

valfun:PartialFunction[Any,Int] = {case'a'=>'A'casex:Int => x*100}vala =Array(1,2,3,4,5)valb = a.reduce(seqno)? println(b)// 15/**

seq_exp=1+2

seq_exp=3+3

seq_exp=6+4

seq_exp=10+5

*/

-def reduceLeft[B >: A](op: (B, T) ?6?0 B): B

從左向右計(jì)算

-def reduceRight[B >: A](op: (T, B) ?6?0 B): B

從右向左計(jì)算

-def reduceLeftOption[B >: A](op: (B, T) ?6?0 B): Option[B]

計(jì)算Option，參考reduceLeft

-def reduceRightOption[B >: A](op: (T, B) ?6?0 B): Option[B]

計(jì)算Option锦积，參考reduceRight

-def reverse:Array[T]

反轉(zhuǎn)序列

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

-def reverseIterator: collection.Iterator[T]

反向生成迭代

-def reverseMap[B](f: (A) ?6?0 B):Array[B]

同 map 方向相反

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

-def sameElements(that: GenIterable[A]): Boolean

判斷兩個(gè)序列是否順序和對(duì)應(yīng)位置上的元素都一樣

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

-def scan[B >: A, That](z: B)(op: (B, B) ?6?0 B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That

用法同 fold，scan會(huì)把每一步的計(jì)算結(jié)果放到一個(gè)新的集合中返回丰介，而 fold 返回的是單一的值

vala =Array(1,2,3,4,5)valb = a.scan(5)(seqno)? ? println(b.mkString(","))// 5,6,8,11,15,20

-def scanLeft[B, That](z: B)(op: (B, T) ?6?0 B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

從左向右計(jì)算

-def scanRight[B, That](z: B)(op: (T, B) ?6?0 B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

從右向左計(jì)算

-def segmentLength(p: (T) ?6?0 Boolean, from: Int): Int

從序列的 from 處開始向后查找背蟆，所有滿足 p 的連續(xù)元素的長(zhǎng)度

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

-def seq: collection.mutable.IndexedSeq[T]

產(chǎn)生一個(gè)引用當(dāng)前序列的 sequential 視圖

-def size: Int

序列元素個(gè)數(shù)鉴分，同length

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

取出當(dāng)前序列中，from 到 until 之間的片段

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

-def sliding(size: Int): collection.Iterator[Array[T]]

從第一個(gè)元素開始带膀，每個(gè)元素和它后面的 size - 1 個(gè)元素組成一個(gè)數(shù)組志珍，最終組成一個(gè)新的集合返回，當(dāng)剩余元素不夠 size 數(shù)垛叨，則停止

vala =Array(1,2,3,4,5)valb = a.sliding(3).toListfor(i<-0to b.length-1){vals ="第%d個(gè)：%s"println(s.format(i,b(i).mkString(",")))? ? }/**

第0個(gè)：1,2,3

第1個(gè)：2,3,4

第2個(gè)：3,4,5

*/

-def sliding(size: Int, step: Int): collection.Iterator[Array[T]]

從第一個(gè)元素開始伦糯，每個(gè)元素和它后面的 size - 1 個(gè)元素組成一個(gè)數(shù)組，最終組成一個(gè)新的集合返回嗽元，當(dāng)剩余元素不夠 size 數(shù)敛纲，則停止

該方法，可以設(shè)置步進(jìn) step剂癌，第一個(gè)元素組合完后淤翔，下一個(gè)從 上一個(gè)元素位置+step后的位置處的元素開始

vala =Array(1,2,3,4,5)valb = a.sliding(3,2).toList//第一個(gè)從1開始， 第二個(gè)從3開始佩谷，因?yàn)椴竭M(jìn)是 2for(i<-0to b.length-1){vals ="第%d個(gè)：%s"println(s.format(i,b(i).mkString(",")))? ? }/**

第0個(gè)：1,2,3

第1個(gè)：3,4,5

*/

-def sortBy[B](f: (T) ?6?0 B)(implicit ord: math.Ordering[B]):Array[T]

按指定的排序規(guī)則排序

vala =Array(3,2,1,4,5)valb = a.sortBy( {x:Int => x})? ? println(b.mkString(","))// 1,2,3,4,5

-def sortWith(lt: (T, T) ?6?0 Boolean):Array[T]

自定義排序方法 lt

vala =Array(3,2,1,4,5)valb = a.sortWith(_.compareTo(_) >0)// 大數(shù)在前println(b.mkString(","))// 5,4,3,2,1

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

使用默認(rèn)的排序規(guī)則對(duì)序列排序

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

-def span(p: (T) ?6?0 Boolean): (Array[T],Array[T])

分割序列為兩個(gè)集合旁壮，從第一個(gè)元素開始，直到找到第一個(gè)不滿足條件的元素止谐檀，之前的元素放到第一個(gè)集合抡谐，其它的放到第二個(gè)集合

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

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

從指定位置開始，把序列拆分成兩個(gè)集合

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

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

從指定偏移處桐猬，是否以某個(gè)序列開始

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

-def startsWith[B](that: GenSeq[B]): Boolean

是否以某個(gè)序列開始

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

-def stringPrefix: String

返回 toString 結(jié)果的前綴

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

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

返回 start 和 end 間的字符序列

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

-def sum: A

序列求和童叠，元素需為Numeric[T]類型

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

-def tail:Array[T]

返回除了當(dāng)前序列第一個(gè)元素的其它元素組成的序列

vala =Array(1,2,3,4,5)valb = a.tail//? 2,3,4,5

-def take(n: Int):Array[T]

返回當(dāng)前序列中前 n 個(gè)元素組成的序列

vala =Array(1,2,3,4,5)valb = a.take(3)//? 1,2,3

-def takeRight(n: Int):Array[T]

返回當(dāng)前序列中，從右邊開始课幕，選擇 n 個(gè)元素組成的序列

vala =Array(1,2,3,4,5)valb = a.takeRight(3)//? 3,4,5

-def takeWhile(p: (T) ?6?0 Boolean):Array[T]

返回當(dāng)前序列中，從第一個(gè)元素開始五垮，滿足條件的連續(xù)元素組成的序列

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

-def toArray:Array[A]

轉(zhuǎn)換成Array類型

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

轉(zhuǎn)換成 Buffer 類型

-def toIndexedSeq: collection.immutable.IndexedSeq[T]

轉(zhuǎn)換成 IndexedSeq 類型

-def toIterable: collection.Iterable[T]

轉(zhuǎn)換成可迭代的類型

-def toIterator: collection.Iterator[T]

同 iterator 方法

-def toList: List[T]

同 List 類型

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

同 Map 類型乍惊，需要被轉(zhuǎn)化序列中包含的元素時(shí) Tuple2 類型數(shù)據(jù)

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

-def toSeq: collection.Seq[T]

同 Seq 類型

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

同 Set 類型

-def toStream: collection.immutable.Stream[T]

同 Stream 類型

-def toVector: Vector[T]

同 Vector 類型

-def transpose[U](implicit asArray: (T) ?6?0Array[U]):Array[Array[U]]

矩陣轉(zhuǎn)換，二維數(shù)組行列轉(zhuǎn)換

val chars =Array(Array("a","b"),Array("c","d"),Array("e","f"))? ? val b = chars.transpose? ? println(b.mkString(","))

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

聯(lián)合兩個(gè)序列放仗，同操作符 ++

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

-def unzip[T1, T2](implicit asPair: (T) ?6?0 (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1],Array[T2])

將含有兩個(gè)元素的數(shù)組润绎，第一個(gè)元素取出組成一個(gè)序列，第二個(gè)元素組成一個(gè)序列

valchars =Array(("a","b"),("c","d"))valb = chars.unzip? ? println(b._1.mkString(","))//a,cprintln(b._2.mkString(","))//b,d

-def unzip3[T1, T2, T3](implicit asTriple: (T) ?6?0 (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1],Array[T2],Array[T3])

將含有三個(gè)元素的三個(gè)數(shù)組诞挨，第一個(gè)元素取出組成一個(gè)序列莉撇，第二個(gè)元素組成一個(gè)序列，第三個(gè)元素組成一個(gè)序列

val chars =Array(("a","b","x"),("c","d","y"),("e","f","z"))? ? val b = chars.unzip3println(b._1.mkString(","))//a,c,eprintln(b._2.mkString(","))//b,d,fprintln(b._3.mkString(","))//x,y,z

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

將序列中 i 索引處的元素更新為 x

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

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

將序列中 i 索引處的元素更新為 x ,并返回替換后的數(shù)組

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

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

返回 from 到 until 間的序列惶傻，不包括 until 處的元素

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

-def withFilter(p: (T) ?6?0 Boolean): FilterMonadic[T,Array[T]]

根據(jù)條件 p 過濾元素

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

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

將兩個(gè)序列對(duì)應(yīng)位置上的元素組成一個(gè)pair序列

vala =Array(1,2,3,4,5)valb =Array(5,4,3,2,1)valc = a.zip(b)? ? println(c.mkString(","))//(1,5),(2,4),(3,3),(4,2),(5,1)

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

同 zip 棍郎，但是允許兩個(gè)序列長(zhǎng)度不一樣，不足的自動(dòng)填充银室，如果當(dāng)前序列端涂佃，空出的填充為 thisElem励翼，如果 that 短，填充為 thatElem

vala =Array(1,2,3,4,5,6,7)valb =Array(5,4,3,2,1)valc = a.zipAll(b,9,8)//(1,5),(2,4),(3,3),(4,2),(5,1),(6,8),(7,8)vala =Array(1,2,3,4)valb =Array(5,4,3,2,1)valc = a.zipAll(b,9,8)//(1,5),(2,4),(3,3),(4,2),(9,1)

-def zipWithIndex:Array[(A, Int)]

序列中的每個(gè)元素和它的索引組成一個(gè)序列

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