初始化固定長度的陣列

// 初始化長度為10的陣列
val array = new Array[Int](10)
// 初始化建立含有hi與hello的陣列
val s = Array("hi","hello")

建立可變的陣列（提供ArrayBuilder()方法）

val a = new StringBuilder()

Scala操作：

def ++ ：a++b

合併集合並返回一個新的陣列，新陣列包含左右兩個集合內容

val a=Array(1,2,3)
val b=Array(2,3,4)
a++b   
 // Array[Int] = Array(1, 2, 3, 2, 3, 4)

def ++: ：

a++:b

合併集合返回新陣列，陣列的型別為靠近:集合的型別

val a=Array(1,2,3)
val b=List(2,3)
a++:b
// List[Int] = List(1, 2, 3, 2, 3)

def +: | :+ ：a+:b or a:+b

在陣列內加入一個常量元素，靠近:的為常量

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

def /: | :\ ：n:Int /: Array[T]　　返回Array[T]

對陣列所有元素進行相同操作，foldLeft(左二叉樹) | foldRight(右二叉樹)簡寫

val a=Array(1,2,3)
(10 /: a)(_+_)
// 16

def addString：addString(a:StringBuilder())　　返回StringBuilder

將陣列中的元素逐個加入到可變陣列中

val a=new StringBuilder()
val b=Array(1,2,3)
b.addString(a)
// StringBuilder = 123

def addString：addString(a:StringBuilder(),sep:String)　　返回StringBuilder

同上，每個元素用sep分開

val a=new StringBuilder()
val b
 
=Array(1,2,3)
b.addString(a,",")
// StringBuilder = 1,2,3

def addString：addString(a:StringBuilder(),start:String,sep:String,end:String)　　返回StringBuilder

同上，在首位多了兩個字串

val a=new StringBuilder()
val b=Array(1,2,3)
b.addString(a,"1",",","2")
// StringBuilder = 11,2,32

def aggregate：aggregate[z:=>B](mapper:(B,T)=>B,reduce:(B,B)=>B):B

聚合計算，aggregate為柯里化方法，兩個引數，其作用相當於mapreduce

def mapper(m:Int,n:Int):Int={m+n}
def reduce(m:Int,n:Int):Int={m+n}
val a=List(1,2,3,4,5)
a.par.aggregate(5)(mapper,reduce)
// Int = 40

def apply(i:Int):T

取出指定索引的元素

val a=Array(1,2,3)
a.apply(2)
//Int=3

def canEqual　　返回boolean

判斷兩個物件是否可以進行比較

def charAt(index:Int)：Char

獲取index索引處的字元

val a=Array('a','b','c')
a.charAt(1)
// Char = b

def clone()：Array[T]

淺拷貝，只拷貝索引，不建立新物件

val a=Array(1,2,3)
val b=a.clone()
// Array[Char] = Array(a, b, c)

def collect()：Array[T]

通過執行一個平行計算（偏函式），得到一個新的陣列物件

val a=Array(1,2,3,4)
val func:PartialFunction[Int,Int]={case x if x%2==0 => x+2 case x => x+1}
a.collect(func)
// Array[Int] = Array(2, 4, 4, 6)

def collectFirst：

對第一個執行偏函式計算

val a=Array(1,2,3,4)
val func:PartialFunction[Int,Int]={case x if x%2==0 => x+2 case x => x+1}
a.collectFirst(func)
// Option[Int] = Some(2)

def combinations(i:Int)　　返回一個迭代器

排列組合，列出所有的包含不同字元的組合

val a=Array(1,2,3)
a.combinations(2).foreach(x=>println(x.mkString(",")))
//1,2
  1,3
  2,3

def contains(ele:A)：boolean

判斷集合中是否包含指定物件

val a=Array(1,2,3)
a.contains(3)
//Boolean = true

def containsSlice(that:Array[T])：boolean

判斷當前序列中是否包含另一個序列，且序列次序一致

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

def copyToArray(Array[T],index,len)

拷貝 (Array[T],index,len) 三種方式 1#帶入一個引數，代表考入的空陣列 2#帶入兩個引數，index代表開始的下標 3#帶入三個引數，len 代表拷貝的長度

val a:Array[Int]=new Array(5)
val b=Array(1,2,3)
b.copyToArray(a)    // Array[Int] = Array(1, 2, 3, 0, 0)
b.copyToArray(a,2)    // Array[Int] = Array(0,0,1, 2, 3)
b.copyToArray(a,2,2)    // Array[Int] = Array(0,0,1, 2, 0)

def copyToBuffer(dest:Buffer)：unit

將陣列中內容拷貝到Buffer內（使用改方法需要先導包：import scala.collection.mutable.ArrayBuffer）

val a=Array(1,2,3)
val b=new ArrayBuffer[Int]()
a.copyToBuffer(b)
//scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

def corresponds()：boolean

判斷兩個序列長度是否相同，對應位置的元素是否滿足判定條件

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

def count(p:=>boolean)：Int

統計符合條件的元素的個數

val e=Array("hello","world","hadoop")
e.count(x=>x.contains("o"))
//3

def diff(Array[T])：Array[T]

返回當前陣列與某一陣列不同的元素,形成一個新陣列

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

def distinct：Array[T]

去重

val a=Array(1,1,1,1,2,2,4,4,6)
a.distinct
// Array[Int] = Array(1, 2, 4, 6)

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

去除當前序列前n個元素並返回一個新的序列

val a=Array(1,1,1,1,2,2,4,4,6)
a.drop(4)
// Array[Int] = Array(2, 2, 4, 4, 6)

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

從尾部開始去掉n個元素並返回

def dropWhile(p:=>boolean)：Array[T]

從第一個元素開始，刪除滿足條件的元素，直到遇到不滿足條件元素並返回後面所有元素

val a=Array(1,2,3,4,5,6,3,2,1,8)
 a.dropWhile(_<5)
//Array[Int] = Array(5, 6, 3, 2, 1, 8)

def endsWith | startsWith(Array[T])：boolean

判斷是否以某個序列結束 |開始

val a=Array(1,2,3,4)
a.startsWith(Array(1,2)) //true
a.endsWith(Array(3,4)) //true

def exists(p=>boolean)：boolean

判斷陣列是否包含符合條件的元素

val a=Array(1,2,3)
a.exists(_>2)
//Boolean = true

def find(p=>boolean)：Option[T]

查詢第一個符合的元素 (Some型別)

val a=Array(1,2,3)
a.find(_>1)
//Option[Int] = Some(2)

def filter | filterNot (p=>boolean)：Array[T]

過濾器，取出元素返回新的陣列

val a=Array(1,2,3,4)
a.filter(_>2)  //Array[Int] = Array(3, 4)
a.filterNot(_>2)  // Array[Int] = Array(1, 2)

def flatten ：Array[T]

陣列降維，返回一個一維陣列

val a=Array(List(1,2),List(3,4))
a.flatten.mkString(",")
//String = 1,2,3,4

def flatMap()：Array[T]

先進行map,再進行降維，對序列內元素進行操作返回一個新序列

val a=Array(1,2,3)
println(a.flatMap(x=>1 to x).mkString(","))
//1,1,2,1,2,3

wordcount:
var words=Array("hello world","hello scala","spark scala")
words.flatMap(x=>x.split(" ")).groupBy(x=>x).foreach(f=>println(f._1,f._2.length))

def fold/foldLeft/foldRight ()

對元素進行二元運算(三個方法結果相同，計算順序不同)

val a=Array(1,2,3)
a.fold(5)(_+_) 
// 11

def forall(p:=>boolean)：boolean

元素都滿足條件則返回true，只要有不滿足的則返回false

val a=Array(1,2,3)
a.forall(_>1)  //false
a.forall(_>0) //true

def foreach()

遍歷

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

def groupBy(f:T=>K)：Map[K,Array[T]]

條件分組，返回鍵值對

val a=List(1,2,3,4)
a.groupBy(x=>x match{case x if (x%2==0) => "ou" case _ => "ji"})
res0.apply("ji")
//  List[Int] = List(1, 3)

def grouped(size:Int)：collection.Iterator

返回迭代器，按照指定的長度對當前集合分組

val a=List(1,2,3,4,5)
a.grouped(2).foreach(x=>println(x))
//List(1, 2, 3)
   List(4, 5)

def hasDefiniteSize：boolean

判斷是否為流資料還是普通資料 普通資料為true

def head：T

返回序列第一個元素

def tail：T

返回序列除了第一個之外的所有元素

val a=List(1,2,3,4)
a.tail
//List[Int] = List(2, 3, 4)

def headOption：Option[T]

返回序列第一個元素，沒有則返回空，解決head序列為空引發報錯的問題

val a:Array[Int]=Array()
a.headOption
// Option[Int] = None

def indexOf(ele:Int)：Int

返回某值在序列中第一次出現的位置int

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

def indexOf(ele:Int,from:Int)：Int

從from位置開始查詢某值在序列中第一次出現的位置

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

def indexOfSlice(Array[T])：Int

返回某一序列被包含於當前序列且匹配的第一個元素的索引

val a=Array(1,2,3,1,2,3,1,2,3)
a.indexOfSlice(Array(1,2,3))
// Int = 0

def indexOfSlice(Array[T],from:Int)：Int

返回某一序列從當前序列的from位置開始檢索，包含且第一個匹配元素出現的索引

val a=Array(1,2,3,1,2,3,1,2,3)
a.indexOfSlice(Array(1,2,3),1)
//Int = 3

def indexWhile(T=>boolean)：Int

返回第一個滿足條件的索引

val a=Array(1,2,3,2,3)
a.indexWhere(_>2)
// Int = 2

def indices：Range

返回當前序列索引集合

val a=Array(1,2,3)
a.indices
//scala.collection.immutable.Range = Range(0, 1, 2)

def intersect

取兩個序列中的交集

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

def isDefinedAt(index:Int)：boolean

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

def init：Array[T]

返回當前序列中不包含最後一個元素的序列 去尾

val a=Array(1,2,3)
a.init
// Array[Int] = Array(1, 2)

def inits

返回迭代器，foreach遍歷

val a=Array(1,2,3)
a.inits
// Iterator[Array[Int]] = non-empty iterator
a.inits.foreach(x=>println(x.mkString(",")))
//1,2,3
   1,2
   1

def isEmpty

是否為空

def isTraversableAgain：boolean

判斷是否可以迴圈遍歷 （判斷是否為迭代器---迭代器不能反覆遍歷）

def iterator：collection.Iterator[T]

迭代器，對序列中的每個元素產生一個 iterator

def last

得到序列中最後一個元素

val a=Array(1,2,3)
a.last
// Int = 3

def lastIndexOf(ele:T)：Int

得到值為T的元素最後一次出現在序列中的位置

val a=Array(1,3,3,2,3)
a.lastIndexOf(3)
// Int = 4

def lastIndexOf(ele:T,end:Int)：Int

得到值為T的元素最後一次出現在序列中的位置,查詢要求為end之前（包括）的索引

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

def lastIndexOfSlice(Array[T])：Int

當前序列包含某序列，且返回該序列最後一次出現時匹配的第一個元素的索引

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

def lastIndexOfSlice(Array[T],end:Int)：Int

當前序列包含某序列，且返回該序列最後一次出現時匹配的第一個元素的索引，查詢位置在end（包含）之前

val a = Array(1,2,3,1,2)
val b = Array(1,2)
a.lastIndexOfSlice(b,2) 
// Int = 0

def lastIndexWhere(p=>boolean)：Int

返回最後一個滿足條件的元素索引

val a=Array(1,2,3,1)
a.lastIndexWhere(x=>x<2)
//Int = 3

def lastIndexWhere(p=>boolean,end:Int)：Int

返回最後一個滿足條件的元素索引,查詢位置在end之前

val a=Array(1,2,3,1)
a.lastIndexWhere(x=>x<2,2)
//Int = 0

def lastOption：T

返回當前序列最後一個物件

val a=Array(1,2,3,1)
a.lastOption
//Option[Int] = Some(1)

def length

序列長度

def lengthCompare(len:Int)：Int

將序列長度和len相比較，返回值為：序列長度-len

val a=Array(1,2,3)
a.lengthCompare(5)
// Int = -2

def map(f:x1=>x2)：Array[T]

對序列中的元素遍歷進行f操作

val a=Array(1,2,3)
a.map(x=>x+2)
// Array[Int] = Array(3, 4, 5)

def max | sum

返回序列最大元素 | 元素和

def maxBy | minBy

返回序列中第一個符合條件的元素 |返回序列中第一個不符合條件的元素

val a=Array(1,2,3)
a.maxBy(_>1)    //Int = 2
a.minBy(_>4)    //Int = 1

def mkString：String

將所有元素組合成一個字串，等同於addString(a:StringBuffer())

def mkString(sep:String)：String

將所有元素組合成一個字串，等同於addString(a:StringBuffer(),sep:String)

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

將所有元素組合成一個字串，等同於addString(a:StringBuffer(),start:String,sep:String,end:String)

val a=Array(1,2,3)
a.mkString("1",",","2")
// String = 11,2,32

def nonEmpty：boolean

判斷是否為空

def padTo(len:Int,ele:T)：Array[T]

後補齊序列，若 序列長度小於len，則：[序列末尾,len]之間全部填充元素ele；若 序列長度大於len，則返回當前序列

val a=Array(1,2,3)
a.padTo(5,4) // Array[Int] = Array(1, 2, 3, 4, 4)
a.padTo(3,4) //  Array[Int] = Array(1, 2, 3)

def par：ParArray[T]

返回一個並行序列且不能被修改，其作用相當於hashcode進行分割槽

def partition(p:=>boolean)：(Array[T],Array[T])

按條件分割槽，滿足放第一序列，不滿足放第二序列,返回的為元組

val a=List(1,2,3,4,5)
a.partition(_>2)
//(List[Int], List[Int]) = (List(3, 4, 5),List(1, 2))

def patch(from:Int,that:GenSeq[T],replaced:Int)：Array[T]

從from處開始，將原序列replaced個元素替換為序列that,that序列長度大於replaced個數，原序列擴容，相反則長度減小

val a=Array(1,2,3,4)
a.patch(2,Array(8,9,10),1)//  Array[Int] = Array(1, 2, 8, 9, 10, 4)
a.patch(0,Array(8,9),3)// Array[Int] = Array(8, 9, 4)

def permutations：collection.Iterator[Array[T]]

排列組合，內容可以相同，順序不能一致（combinations排列內容和順序都不一致）

val a=Array(1,2,3)
a.permutations.foreach(x=>println(x.mkString(",")))
//1,2,3
  1,3,2
  2,1,3
  2,3,1
  3,1,2
  3,2,1

def prefixLength(p=>boolean)：Int

由第一個索引開始，返回序列中滿足條件p的元素數量，直到有不滿足的則結束

val a=Array(1,2,3,4,3,2,1)
a.prefixLength(_<3)
// Int = 2

def product：T

返回元素乘積的值

def reduce

作用和fold相似，fold需要一個初始值，而reduce不需要

val a=Array(1,2,3)
a.reduce(_+_)
//Int = 6

def reduceLeft/reduceRigtht

作用類似於foldLeft/foldRight

def reduceLeftOption/reduceRightOption

作用於上面相同，Option為了解決元素為空時報錯問題

def reverse：Array[T]

返回倒序列

val a=Array(1,2,3)
a.reverse
//Array[Int] = Array(3, 2, 1)

def reverseIterator：collection.Iterator[T]

反向迭代器

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

def reverseMap(f:x=>x1)：Array[T]

反向map

val a=Array(1,2,3)
a.reverseMap(x=>x+2)
//Array[Int] = Array(5, 4, 3)

def sameElements(that:Array[T])：boolean

兩個序列順序與對應位置的元素是否相同

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

def scan/scanLeft/scanRight

用法同 fold，scan會把每一步的計算結果放到一個新的集合中返回，而 fold 返回的是單一的值,reduce不帶引數,返回單一值

val a=Array(1,2,3)
a.scan(5)(_+_)
// Array[Int] = Array(5, 6, 8, 11)

def segmentLength(p=>boolean,from:Int)：Int

從序列的 from 處開始向後查詢，所有滿足 p 的連續元素的長度

val a=Array(1,2,3,4,5,6)
a.segmentLength(_>2,0) //Int = 0
a.segmentLength(_<5,0) //Int = 4

def seq：collection.mutable.IndexedSeq[T]

產生一個引用當前序列的 sequential 檢視

val a=Array(1,2,3)
a.seq
// scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5, 6)

def size：Int

統計長度，碰到空也統計（不同與java）

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

取出當前序列中，from 到 until 之間的片段(前包後不包)

val a=Array(1,2,3,4,5)
a.slice(1,3)
//Array[Int] = Array(2, 3)

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

由第一個元素開始，每size個元素組成一個數組，直到當前序列長度不夠

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

def sortBy(f:T=>B)：Array[T]

按指定的排序規則排序

val a=Array(1,4,2,5,6,3)
a.sortBy(x=>x) //正序
//Array[Int] = Array(1, 2, 3, 4, 5, 6)
a.sortBy(x=>(-x)) //倒序
//Array[Int] = Array(6, 5, 4, 3, 2, 1)

def sortWith(t:(T,T)=>boolean)：Array[T]

自定義排序方法 t

val a=Array(2,3,4,1,5,6,3)
a.sortWith(_.compareTo(_)>0)//倒序
// Array[Int] = Array(6, 5, 4, 3, 3, 2, 1)

def sorted：Array[T]

預設排序

val a=Array(2,3,4,1,5,6,3)
a.sorted
//Array[Int] = Array(1, 2, 3, 3, 4, 5, 6)

def span(p=>boolean)：(Array[T],Array[T])

分割序列為兩個集合，從第一個元素開始，直到找到第一個不滿足條件的元素止，之前的元素放到第一個集合，其它的放到第二個集合

val a=Array(1,2,3,4,5)
a.span(_>2)
// (Array[Int], Array[Int]) = (Array(),Array(1, 2, 3, 4, 5))

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

從指定位置(位於後一個Array[T])開始，把序列拆分成兩個集合

val a=Array(1,2,3,4,5)
a.splitAt(2)
// (Array[Int], Array[Int]) = (Array(1, 2),Array(3, 4, 5))

def toString

返回toString結果字首

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

返回 start 和 end 間的字元序列 左包又不包 只針對char型別(前包後不包)

val a=Array('a','b','c')
a.subSequence(0,2)
// CharSequence = ab

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

返回當前序列中前 n 個元素組成的序列

val a=Array(1,2,3,4)
a.take(3)
// Array[Int] = Array(1, 2, 3)

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

返回當前序列中，從右邊開始，選擇 n 個元素組成的序列

val a=Array(1,2,3)
a.takeRight(1)
// Array[Int] = Array(3)

//返回中間元素
a.take(2).takeRight(1)
// Array[Int] = Array(2)