Scala一種程式語言
scala
安裝
安裝scala
去官網下載scala2.11.8（spark使用2.1.2對應scala版本是2.11.8）
下載scala-2.11.8.msi（安裝）或scala-2.11.8.zip（解壓）
注意：scala安裝目錄不能有中文和空格（特殊符號）
安裝idea
下一步。。。。
configurens--》plugins--》搜尋 “scala”--》install ---》 restart intellij
new project --》 選擇scala --》選擇IDEA -->next---》填寫工程名 --》
jdk路徑（選擇本地的jdk1.8安裝目錄） --》 scala sdk --》scala安裝目錄--》finish
特點
面向物件 1+2 (1).+(2)
函式式
相容的
簡潔的
高層級的
靜態型別的
互動模式
定義變數
val 常量（推薦）
var 變數
型別推斷
這種 Scala能自動理解你省略的型別的能力
val msg2: java.lang.String = "Hello again, world!"
指定型別 變數：型別 = 值
定義函式
def 函式名(引數列表[變數名：型別]):結果型別 = ｛
方法體
｝
list(不可變型別必須一致)
List() 或 Nil 空 List
List("Cool", "tools", "rule) 建立帶有三個值"Cool"，"tools"和"rule"的新 List[String]
val thrill = "Will"::"fill"::"until"::Nil 建立帶有三個值"Will"，"fill"和"until"的新 List[String]
List("a", "b") ::: List("c", "d") 疊加兩個列表（返回帶"a"，"b"，"c"和"d"的新List[String]）
thrill(2) 返回在 thrill 列表上索引為 2（基於0）的元素（返回"until"）
thrill.count(s => s.length == 4) 計算長度為 4 的 String 元素個數（返回 2）
thrill.drop(2) 返回去掉前 2 個元素的thrill 列表（返回 List("until")）
thrill.dropRight(2) 返回去掉後 2 個元素的thrill 列表（返回 List("Will")）
thrill.exists(s => s == "until") 判斷是否有值為"until"的字串元素在 thrill 裡（返回 true）
thrill.filter(s => s.length == 4) 依次返回所有長度為 4 的元素組成的列表（返回 List("Will","fill")）
thrill.forall(s => s.endsWith("1")) 辨別是否 thrill 列表裡所有元素都以"l"結尾（返回 true）
thrill.foreach(s => print(s)) 對 thrill 列表每個字串執行 print 語句（"Willfilluntil"）
thrill.foreach(print) 與前相同，不過更簡潔（同上）
thrill.head 返回 thrill 列表的第一個元素（返回"Will"）
thrill.init 返回 thrill 列表除最後一個以外其他元素組成的列表（返回List("Will", "fill")）
thrill.isEmpty 說明 thrill 列表是否為空（返回false）
thrill.last 返回 thrill 列表的最後一個元素（返回"until"）
thrill.length 返回 thrill 列表的元素數量（返回3）
thrill.map(s => s + "y") 返回由 thrill 列表裡每一個 String 元素都加了"y"構成的列表（返回 List("Willy", "filly", "untily")）
thrill.mkString(", ") 用列表的元素建立字串（返回"will, fill, until"）
thrill.remove(s => s.length == 4) 返回去除了 thrill 列表中長度為 4 的元素後依次排列的元素列表（返回 List("until")）
thrill.reverse 返回含有 thrill 列表的逆序元素的列表（返回 List("until","fill", "Will")）
thrill.sort((s, t) =>s.charAt(0).toLowerCase <t.charAt(0).toLowerCase)
返回包括 thrill 列表所有元素，並且第一個字元小寫按照字母順序排列的列表（返回List("fill", "until", "Will")）
thrill.tail 返回除掉第一個元素的 thrill 列表（返回 List("fill","until")）
Tuple(不可變型別可以不一致)
Set
可變scala.collection.mutable.Set
不可變scala.collection.immutable.Set
map
可變scala.collection.mutable.Map
不可變scala.collection.immutable.Map
---------------------------------------------------
1.方法中的花括號有2種意思：
1）scala中函式的小括號，可以用花括號來表示，即foo{xx} 與 foo(xx)是一回事兒。
2）對於只有一個引數的方法，其小括號是可以省略的，map(lambda)可寫為 map lambda，即這塊{case (key,value) => value} 連同花括號整體是一個lambda(函式字面量)。
// 花括號和小括號的區別
val raw = List(("a",1),("b",2),("c",3))
val res = raw.map{ case (key,value) => value }.reduce(_ + _)
println(res)
2.{case x => y} 叫做偏函式(必須用大括號“｛｝”，使用“（）”會報錯)。 與完全函式想對應，普通的方法都是完全函式，即f(i:Int) = xxx 是將所有Int型別作為引數的，是對整個Int集的對映；而偏函式則是對部分資料的對映
// 2.case偏函式
val res2 =List(1,2,3).map{
case 1 => "first"
case 2 => "second"
case _ => "other"
3.變長引數
有時候，函式需要一個可變長度的引數。在scala中是容易實現的：
注意呼叫的時候使用:_*，將序列或者集合的內容全部當做引數來傳遞。
// 3.變長引數
def sum(args:Int*)={
var result = 0
for(arg <- args) result +=arg
print (result)
}
val s = sum (1 to 5:_*)
12.03
類：
類似java
class 類名
屬性
val（不可變）或var（可變） 變數名 = 值
方法
del 方法名（引數）：結果型別 = ｛方法體｝
訪問許可權
private與java類似
Singleton 物件
Scala 比 Java 更面向物件的一個方面是 Scala 沒有靜態成員。替代品是，
Scala 有： 單例物件：singleton object。
當單例物件與某個類共享同一個名稱時，他被稱作是這個類的 伴生物件
你必須在同一個原始檔裡定義類和它的伴生物件。
類被稱為是這個單例物件的 伴生類：companionclass。
類和它的伴生物件可以互相訪問其私有成員。
scala程式
要執行 Scala 程式，你一定要提供一個有 main 方法
（僅帶一個引數， Array[String] ，且結果型別為 Unit ）的孤立單例物件名
Application 特質
可以不寫main方法直接執行，繼承Application
object 物件名 extends Application {
此處語句可以直接執行，不需要main方法
｝
args 陣列不可訪問
某些 JVM執行緒模型裡的侷限，使用多執行緒必須寫main
基本資料型別：
java中八個加上String
中置操作符
操作符位於兩個引數之間
一元操作符
只有一個引數的操作符
結合性
所有操作符都是左結合（從左到右計算）
：和賦值是右結合
scala高階函式
接收函式引數的函式
函數語言程式設計
--------------------------------------------
函數語言程式設計的特點
函數語言程式設計核心價值在於多核程式設計。
1） 引數私有，沒有執行緒安全問題，這樣就為分散式高併發提供了支援
2） 把函式做為引數
3） 把函式的返回值作為引數
定義:在js中方法和函式比較模糊。scala中的函式和方法不同，函式在scala中是一等公民。
格式：(引數：型別):返回值型別 => { 表示式； 表示式... }
函式可以被賦值給其他變數或常量，可以作為引數傳遞，也可以作為返回值
object TestFunction {
def add(a:Int,b:Int) = { a+b } //定義物件的方法
def main(args: Array[String]): Unit = {
val fnadd = (a:Int,b:Int) => { a+b } //定義函式
println(fnadd(10,20))
}
}------------------------------------------------------------------------------------------------------------------------
函式程式設計的威力
任務：已存在一個數字集合，按照奇偶數分成兩個集合，下面是java的實現
java實現:
List<Integer> list = new ArrayList<Integer>();
list.add(1); list.add(2); list.add(3); list.add(4); list.add(5);
List<Integer> a = new ArrayList<Integer>();
List<Integer> b = new ArrayList<Integer>();
for(Integer n: list){
if(n%2 == 0){
a.add(n);
}else{
b.add(n);
}
}scala實現
object list {
def main(args: Array[String]): Unit = {
//按奇偶數將集合劃分為兩個
val f2 = (n:Int) => {n%2 != 0} //函式遇到奇數返回true，偶數返回false
val array = Array(1,2,3,4,5).toList //初始化陣列
println(array.partition(f2)) // partition分割槽的意思
//還可以簡寫為
println(array.partition((n:Int) => {n%2 != 0}))
}
}
結果：(List(1, 3, 5),List(2, 4))
可以看到函數語言程式設計的好處，讓程式碼變的簡單。
以前面向物件是做抽象、繼承、封裝、多型，以物件的觀點去寫我們的程式。函數語言程式設計把程式碼寫在一個一個小的函式中，想辦法把業務化成一塊一塊的內容，組合起來完成一個業務。
------------------------------------------------------------------------------------------------------------------------
函式式的foreach
val list2 = List(1,2,3,4,5)
list2.foreach { x => println(x) }
【foreach原始碼說明】：
def foreach[U](f: A => U) { //f是一個函式，A、U都是泛型
var these = this
while (!these.isEmpty) {
f(these.head) //.head獲取到頭元素也就是第一個元素
these = these.tail //.tail獲取到除第一元素後的所有元素
}
}
集合操作
------------------------------
def ++[B](that: GenTraversableOnce[B]): Array[B]
合併集合，並返回一個新的陣列，新陣列包含左右兩個集合物件的內容。型別返回已左側為準！！
val a = Array(1,2,3)
val b = Array(3,4,5)
val c = a ++ b//c中的內容是(1,2,3,3,4,5)
--------------------------------------------------------------------------------------------------------------------------------------
def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
這個方法同上一個方法類似，兩個加號後面多了一個冒號，但是不同的是右邊操縱數的型別決定著返回結果的型別。
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]
在陣列前面新增一個元素，並返回新的物件，下面新增一個元素 0
val a = List(1,2)
val c = 0 +: a // c中的內容是 （0,1,2）
--------------------------------------------------------------------------------------------------------------------------------------
def :+(elem: A): Array[A]
同上面的方法想法，在陣列末尾新增一個元素，並返回新物件
--------------------------------------------------------------------------------------------------------------------------------------
def addString(b: StringBuilder): StringBuilder
將陣列中的元素逐個新增到b中
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b)// c中的內容是 1234
--------------------------------------------------------------------------------------------------------------------------------------
def addString(b: StringBuilder, sep: String): StringBuilder
同上，每個元素用sep分隔符分開
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,",")
println("c: "+c) // c: 1,2,3,4
--------------------------------------------------------------------------------------------------------------------------------------
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
同上，在首尾各加一個字串，並指定sep分隔符
val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,"{",",","}")
println("c: "+c) // c: {1,2,3,4}
--------------------------------------------------------------------------------------------------------------------------------------
def mkString: String
將所有元素組合成一個字串
val a = Array(1, 2, 3, 4, 5)
println(a.mkString) // return 12345
**************************************************************************************************************************************
def mkString(sep: String): String
將所有元素組合成一個字串，以 sep 作為元素間的分隔符
val a = Array(1, 2, 3, 4, 5)
println(a.mkString(",")) // return 1,2,3,4,5
**************************************************************************************************************************************
def 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}
**************************************************************************************************************************************
def aggregate[B](z: => B)(seqop: (B, T) => B, combop: (B, B) => B): B
聚合計算，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)(_+_,_+_)
12.04
def apply(i: Int): T
同下面程式碼，取出指定索引處的元素
val first = numbers(0) // 讀取第一個元素
--------------------------------------------------------------------------------------------------------------------------------------
def canEqual(that: Any): Boolean
判斷兩個物件是否可以進行比較
--------------------------------------------------------------------------------------------------------------------------------------
def charAt(index: Int): Char
獲取index索引處的字元，這個方法會執行一個隱式的轉換，將Array[T]轉換為 ArrayCharSequence，只有當T為char型別時，這個轉換才會發生。
val chars = Array('a','b','c')
println("c:"+chars.charAt(0))//結果 a
--------------------------------------------------------------------------------------------------------------------------------------
def clone(): Array[T]
建立一個副本
val chars = Array('a','b','c')
val newchars = chars.clone()--------------------------------------------------------------------------------------------------------------------------------------
def collect[B](pf: PartialFunction[A, B]): Array[B]
通過執行一個平行計算（偏函式），得到一個新的陣列物件
val chars = Array('a','b','c')
val newchars = chars.collect(fun)
println("newchars:"+newchars.mkString(","))//我們通過下面的偏函式，把chars陣列的小寫a轉換為大寫的A
val fun:PartialFunction[Char,Char] = {
case 'a' => 'A'
case x => x
}/**輸出結果是 newchars:A,b,c */
--------------------------------------------------------------------------------------------------------------------------------------
def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
在序列中查詢第一個符合偏函式定義的元素，並執行偏函式計算
val arr = Array(1,'a',"b")
//定義一個偏函式，要求當被執行物件為Int型別時，進行乘100的操作，對於上面定義的物件arr來說，只有第一個元素符合要求
val fun:PartialFunction[Any,Int] = {
case x:Int => x*100
}//計算
val value = arr.collectFirst(fun)
println("value:"+value)
//另一種寫法
val value = arr.collectFirst({case x:Int => x*100})--------------------------------------------------------------------------------------------------------------------------------------
def combinations(n: Int): collection.Iterator[Array[T]]
排列組合，這個排列組合會選出所有包含字元不一樣的組合，對於 “abc”、“cba”，只選擇一個，引數n表示序列長度，就是幾個字元為一組
val arr = Array("a","b","c")
val newarr = arr.combinations(2)
newarr.foreach((item) => println(item.mkString(",")))/**
a,b
a,c
b,c
*/
--------------------------------------------------------------------------------------------------------------------------------------
def contains[A1 >: A](elem: A1): Boolean
序列中是否包含指定物件
--------------------------------------------------------------------------------------------------------------------------------------
def containsSlice[B](that: GenSeq[B]): Boolean
判斷當前序列中是否包含另一個序列
val a = List(1,2,3,4)
val b = List(2,3)
println(a.containsSlice(b)) //true
--------------------------------------------------------------------------------------------------------------------------------------
def copyToArray(xs: Array[A]): Unit
此方法還有兩個類似的方法
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',0,0]*/
a.copyToArray(b,1) /**b中元素 [0,'a',b,c,0]*/
a.copyToArray(b,1,2) /**b中元素 [0,'a','b',0,0]*/
--------------------------------------------------------------------------------------------------------------------------------------
def copyToBuffer[B >: A](dest: Buffer[B]): Unit
將陣列中的內容拷貝到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) => Boolean): Boolean
判斷兩個序列長度以及對應位置元素是否符合某個條件。如果兩個序列具有相同的元素數量並且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
--------------------------------------------------------------------------------------------------------------------------------------
def count(p: (T) => Boolean): Int
統計符合條件的元素個數，下面統計大於 2 的元素個數
val a = Array(1, 2, 3)
println(a.count({x:Int => x > 2})) // count = 1
--------------------------------------------------------------------------------------------------------------------------------------
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)
println(c.mkString) //1,2,3
--------------------------------------------------------------------------------------------------------------------------------------
def distinct: Array[T]
去除當前集合中重複的元素，只保留一個
val a = Array(1, 2, 3,4,4,5,6,6)
val c = a.distinct
println(c.mkString(",")) // 1,2,3,4,5,6
--------------------------------------------------------------------------------------------------------------------------------------
def drop(n: Int): Array[T]
將當前序列中前 n 個元素去除後，作為一個新序列返回
val a = Array(1, 2, 3,4)
val c = a.drop(2)
println(c.mkString(",")) // 3,4
--------------------------------------------------------------------------------------------------------------------------------------
def dropRight(n: Int): Array[T]
功能同 drop，去掉尾部的 n 個元素
def 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)
--------------------------------------------------------------------------------------------------------------------------------------
def endsWith[B](that: GenSeq[B]): Boolean
判斷是否以某個序列結尾
val a = Array(3, 2, 3,4)
val b = Array(3,4)
println(a.endsWith(b)) //true
--------------------------------------------------------------------------------------------------------------------------------------
def exists(p: (T) => Boolean): Boolean
判斷當前陣列是否包含符合條件的元素
val a = Array(3, 2, 3,4)
println(a.exists( {x:Int => x==3} )) //true
println(a.exists( {x:Int => x==30} )) //false
--------------------------------------------------------------------------------------------------------------------------------------
def filter(p: (T) => Boolean): Array[T]
取得當前陣列中符合條件的元素，組成新的陣列返回
val a = Array(3, 2, 3,4)
val b = a.filter( {x:Int => x> 2} )
println(b.mkString(",")) //3,3,4
--------------------------------------------------------------------------------------------------------------------------------------
def filterNot(p: (T) => Boolean): Array[T]
與上面的 filter 作用相反
def find(p: (T) => Boolean): Option[T]
查詢第一個符合條件的元素
val a = Array(1, 2, 3,4)
val b = a.find( {x:Int => x>2} )
println(b) // Some(3)
--------------------------------------------------------------------------------------------------------------------------------------
def flatMap[B](f: (A) => GenTraversableOnce[B]): Array[B]
對當前序列的每個元素進行操作，結果放入新序列返回，引數要求是GenTraversableOnce及其子類
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
*/
--------------------------------------------------------------------------------------------------------------------------------------
def flatten[U](implicit asTrav: (T) => collection.Traversable[U], m: ClassTag[U]): Array[U]
將二維陣列的所有元素聯合在一起，形成一個一維陣列返回
val dArr = Array(Array(1,2,3),Array(4,5,6))
val c = dArr.flatten
println(c.mkString(",")) //1,2,3,4,5,6
-------------------------------------------------------------------------------
-def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
對序列中的每個元素進行二元運算，和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)
/** 運算過程
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進行處理
**************************************************************************************************************************************
-def foldLeft[B](z: B)(op: (B, T) => B): B
從左到右計算，簡寫方式：def /:[B](z: B)(op: (B, T) => B): B
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)(_+_)
*/
**************************************************************************************************************************************
-def foldRight[B](z: B)(op: (B, T) => B): B
從右到左計算，簡寫方式：def :\[B](z: B)(op: (T, B) => B): B
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)(_+_)
*/
**************************************************************************************************************************************
--------------------------------------------------------------------------------------------------------------------------------------
def /:[B](z: B)(op: (B, T) => B): B
對陣列中所有的元素進行相同的操作 ，foldLeft的簡寫
val a = List(1,2,3,4)
val c = (10 /: a)(_+_) // 1+2+3+4+10
val d = (10 /: a)(_*_) // 1*2*3*4*10
println("c:"+c) // c:20
println("d:"+d) // d:240
--------------------------------------------------------------------------------------------------------------------------------------
def :\[B](z: B)(op: (T, B) => B): B
foldRight的簡寫
-------------------------------------------------------------------------------------------------------------------
-def 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
**************************************************************************************************************************************
-def foreach(f: (A) => Unit): Unit
遍歷序列中的元素，進行 f 操作
val a = Array(1, 2, 3,4)
a.foreach(x => println(x*10))
/**
10
20
30
40
*/
**************************************************************************************************************************************
-def groupBy[K](f: (T) => K): Map[K, Array[T]]
按條件分組，條件由 f 匹配，返回值是Map型別，每個key對應一個序列，下面程式碼實現的是，把小於3的數字放到一組，大於3的放到一組，返回Map[String,Array[Int]]
val a = Array(1, 2, 3,4)
val b = a.groupBy( x => x match {
case x if (x < 3) => "small"
case _ => "big"
})
**************************************************************************************************************************************
-def 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
*/
**************************************************************************************************************************************
-def hasDefiniteSize: Boolean
檢測序列是否存在有限的長度，對應Stream這樣的流資料，返回false
val a = Array(1, 2, 3,4,5)
println(a.hasDefiniteSize) //true
**************************************************************************************************************************************
-def head: T
返回序列的第一個元素，如果序列為空，將引發錯誤
val a = Array(1, 2, 3,4,5)
println(a.head) //1
**************************************************************************************************************************************
-def headOption: Option[T]
返回Option型別物件，就是scala.Some 或者 None，如果序列是空，返回None
val a = Array(1, 2, 3,4,5)
println(a.headOption) //Some(1)
**************************************************************************************************************************************
-def indexOf(elem: T): Int
返回elem在序列中的索引，找到第一個就返回
val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3)) // return 1
-def indexOf(elem: T, from: Int): Int
返回elem在序列中的索引，可以指定從某個索引處（from）開始查詢，找到第一個就返回
val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3,2)) // return 3
**************************************************************************************************************************************
-def 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
**************************************************************************************************************************************
-def 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
**************************************************************************************************************************************
-def indexWhere(p: (T) => Boolean): Int
返回當前序列中第一個滿足 p 條件的元素的索引
val a = Array(1, 2, 3, 4)
println(a.indexWhere( {x:Int => x>3})) // return 3
**************************************************************************************************************************************
-def 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
**************************************************************************************************************************************
-def indices: collection.immutable.Range
返回當前序列索引集合
val a = Array(10, 2, 3, 40, 5)
val b = a.indices
println(b.mkString(",")) // 0,1,2,3,4
**************************************************************************************************************************************
-def init: Array[T]
返回當前序列中不包含最後一個元素的序列
val a = Array(10, 2, 3, 40, 5)
val b = a.init
println(b.mkString(",")) // 10, 2, 3, 40
**************************************************************************************************************************************
-def 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個值
*/
**************************************************************************************************************************************
-def 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
**************************************************************************************************************************************
-def isDefinedAt(idx: Int): Boolean
判斷序列中是否存在指定索引
val a = Array(1, 2, 3, 4, 5)
println(a.isDefinedAt(1)) // true
println(a.isDefinedAt(10)) // false
**************************************************************************************************************************************
-def isEmpty: Boolean
判斷當前序列是否為空
-def isTraversableAgain: Boolean
判斷序列是否可以反覆遍歷，該方法是GenTraversableOnce中的方法，對於 Traversables 一般返回true，對於 Iterators 返回 false，除非被複寫
-def iterator: collection.Iterator[T]
對序列中的每個元素產生一個 iterator
val a = Array(1, 2, 3, 4, 5)
val b = a.iterator //此時就可以通過迭代器訪問 b
**************************************************************************************************************************************
-def last: T
取得序列中最後一個元素
val a = Array(1, 2, 3, 4, 5)
println(a.last) // return 5
**************************************************************************************************************************************
-def lastIndexOf(elem: T): Int
取得序列中最後一個等於 elem 的元素的位置
val a = Array(1, 4, 2, 3, 4, 5)
println(a.lastIndexOf(4)) // return 4
**************************************************************************************************************************************
-def lastIndexOf(elem: T, end: Int): Int
取得序列中最後一個等於 elem 的元素的位置，可以指定在 end 之前（包括）的元素中查詢
val a = Array(1, 4, 2, 3, 4, 5)
println(a.lastIndexOf(4,3)) // return 1
**************************************************************************************************************************************
-def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
判斷當前序列中是否包含序列 that，並返回最後一次出現該序列的位置處的索引
val a = Array(1, 4, 2, 3, 4, 5, 1, 4)