scala函数大全（二）

apply

获取指定索引处的元素

val a = List(1,2,3,4)
val b = a.apply(0)
println(b) //1

canEqual

判断两个对象是否可以进行比较

val a = List(1,2,3,4)
val b = Array('a','b','c')
println(a.canEqual(b))  //true

charAt

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

val chars = Array('a','b','c')  //Char类型
println(chars.charAt(0))  //a

clone

创建一个副本

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

collect

通过执行一个并行计算(偏函数)，得到一个新的数组对象

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

collectFirst

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

val fun:PartialFunction[Any,Int]={
  case x:Int => x*100
}
val a = Array(1,"a",'b')
val b = a.collectFirst(fun)
println(b)  //some(100)
println(b.getOrElse(10)) //100
//第二种写法
val c = a.collectFirst({case x:Int => x*200})
println(c.getOrElse(10)) //200

combinations

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

combinations表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于abc和cba视为相同的组合，参数n表示序列长度，就是几个字符为一组

val a = Array('a','b','c','d')
val b = a.combinations(3) //类型 Iterator[Array[Char]]	
b.foreach(x=>{println(x.getClass.getName);println(x.mkString(","))})
//x的类型是 Array[Char]
b.foreach(x=>{println(x.getClass.getName);x.foreach(println)})

contains

判断序列中是否包含指定对象

val a = List(1,2,3,4)
println(a.contains(1))  //true

containsSlice(xs)

判断当前序列中是否包含另一个序列

val a = List(1,2,3,4)
val b = List(2,3)
println(a.containsSlice(b))  //true
val c = List(2,4)
println(a.containsSlice(c))  //false 讲究顺序

copyToArray()

将当前数组元素复制到另一个数组中

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

copyToArray(xs,start)

将当前数组元素复制到另一个数组中，从start位置开始复制

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

copyToArray(xs,start,len)

将当前数组元素复制到另一个数组中，从start位置开始复制，长度为len

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

copyToBuffer

将数组中的元素复制到Buffer中

val a = Array(1,2,3,4)
//变长数组  类似ArrayList
val b:ArrayBuffer[Int] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(",")) //1,2,3,4

corresponds

判断两个序列的长度及对应的位置元素是否符合某个条件，如果两个序列具有相同的元素数量并且 p(x,y)=true,返回true

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

count

统计符合条件的 元素个数

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

diff

计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回

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

distinct

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

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

drop

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

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

dropRight

功能同drop，去掉尾部的n个元素

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

dropWhile

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

val a = Array(1,2,3,4)
val b = a.dropWhile(x=>x<2)
println(b.mkString(","))  //2,3,4
//如果第一个元素就不满足，返回整个数组
val c = a.dropWhile(x=>x>2)
println(c.mkString(","))  //1,2,3,4

endsWith

判断当前序列是否以某个序列结尾

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

exists

判断当前数组是否包含符合条件的元素

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

filter

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

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

find

查找第一个符合条件的元素，返回Option

val a = Array(1,2,3,4)
val b = a.find(x=>x>2)
println(b)  //some(3)
println(b.getOrElse(0))  //3

flatMap

对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是 GenTraversableOnce 及其子类

val a = Array(1,2,3,4)
val b = a.flatMap(x=> 1 to x) //返回Array[Int]
println(b.mkString(",")) //1,1,2,1,2,3,1,2,3,4
val aa = Array(Array(1,2),Array(3,4))
val c = aa.flatMap(x=>x)
println(c.mkString(",")) //1,2,3,4

flatten

扁平化，将二维数组的所有元素组合在一起，形成一个一维数组

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

fold

对序列中的每个元素进行二元运算，和aggregate的seqno方法相同

def seqno(m:Int,n:Int):Int={
  val s = "seq_exp = %d + %d"
  println(s.format(m,n))
  m + n
}
val a = Array(1,2,3,4)
val b = a.fold(5)(seqno)// 初始值5 不分区
println("b = "+b)

val a = Array(1,2,3,4)
val b = a.fold(5)((x,y)=>{val s = "seq_exp = %d + %d";println(s.format(x,y));x+y})
println("b = "+b)

val c = a.par.fold(5)(seqno)  //分区
println(c)

foldLeft

从左向右计算，类似 /: fold 方法

def seqno(m:Int,n:Int):Int={
  val s = "seq_exp = %d + %d"
  println(s.format(m,n))
  m + n
}
val a = Array(1,2,3,4)
val b = a.foldLeft(5)(seqno)
println("b = "+b)

foldRight

从右到左计算，类似 :\ 方法

def seqno(m:Int,n:Int):Int={
  val s = "seq_exp = %d + %d"
  println(s.format(m,n))
  m + n
}
val a = Array(1,2,3,4)
val b = a.foldRight(5)(seqno)
println("b = "+b)

forall

检测序列中的元素是否都满足条件，都满足返回true

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

foreach

遍历序列中的元素，进行其他操作

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

groupBy

按条件分组，返回值是Map类型，每个k对应一个数组，
Map中的每个键值对是Tuple类型

val a = Array(1,2,3,4)
val b = a.groupBy(x => x match{
  case x if(x<3)=>"small"
  case _=>"big"
})
b.foreach(x=>println(x.getClass.getName))
b.foreach(x=>println(x._1+":"+x._2.mkString(",")))

grouped

def grouped(size: Int): collection.Iterator[Array[T]]
按指定数量分组，每组有size个元素，返回一个迭代器

val a = Array(1,2,3,4,5)
val b = a.grouped(3).toArray
//b: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5))
b.foreach(x=>println(x.mkString(",")))

hasDefiniteSize

def hasDefiniteSize: Boolean
检测序列是否存在有限的长度，对应Stream这样的流数据返回false

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

head

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

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

headOption

def headOption: Option[T]
返回序列的第一个元素的Option类型的对象，如果序列为空，返回None

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

indexOf(elem)

def indexOf(elem: T): Int
返回元素elem在序列中第一次出现的索引

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

indexOf(elem,from)

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

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

indexOfSlice(that)

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

检测当前序列中是否包含序列that,并返回第一次出现该序列的索引

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

indexOfSlice(that,from)

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

检测当前序列中是否包含另一个序列 that，指定从索引 from 开始查找，并返回第一次出现该序列的索引

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

indexWhere(f)

def indexWhere(f: (T) ⇒ Boolean): Int

返回当前序列中第一个满足条件 f 的元素的索引

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

indexWhere(f,from)

def indexWhere(f: (T) ⇒ Boolean, from: Int): Int

返回当前序列中第一个满足条件 f 的元素的索引，指定从索引 from 开始查找

val a = Array(1,2,3,4)
println(a.indexWhere(x=>x>2,3))  //3  4的索引

indices

def indices: collection.immutable.Range

返回当前序列索引集合

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

init

def init: Array[T]

返回当前序列中不包含最后一个元素的序列

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

inits

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

对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象

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

val a = Array(1,2,3,4)
val b = a.inits.toList
for(i <- 0 to b.length - 1){
  val s = "第 %d 组的值是：%s"
  println(s.format(i+1,b(i).mkString(",")))
}

intersect

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

取两个集合的交集

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

isDefinedAt

def isDefinedAt(idx: Int): Boolean

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

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

isEmpty

def isEmpty: Boolean

判断序列是否为空

val a = Array(1,2,3,4)
val b = new Array[Int](0)
println(a.isEmpty)  //false
println(b.isEmpty)  //true

isTraversableAgain

def isTraversableAgain: Boolean

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

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

iterator

def iterator: collection.Iterator[T]

生成当前序列的迭代器

val a = Array(1,2,3,4)
//b: Iterator[Int] = non-empty iterator
val b = a.iterator
println(b.mkString(","))  //1,2,3,4

last

def last: T

返回序列的最后一个元素，如果序列为空，将引发错误

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

lastIndexOf(elem)

def lastIndexOf(elem: T): Int

返回元素 elem 在序列中最后一次出现的索引

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

lastIndexOf(elem,end)

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

返回元素 elem 在序列中最后一次出现的索引，指定在索引 end 之前（包括）的元素中查找

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

lastIndexOfSlice(that)

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

检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引

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

lastIndexOfSlice(that,end)

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

检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引，指定在索引 end 之前（包括）的元素中查找

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

lastIndexWhere(f)

ef lastIndexWhere(f: (T) ⇒ Boolean): Int

返回当前序列中最后一个满足条件 f 的元素的索引

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

lastIndexWhere(f,end)

def lastIndexWhere(f: (T) ⇒ Boolean, end: Int): Int

返回当前序列中最后一个满足条件 f的元素的索引，指定在索引 end 之前（包括）的元素中查找

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

lastOption

def lastOption: Option[T]

返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None

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

length

def length: Int

返回序列元素个数

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

lengthCompare

def lengthCompare(len: Int): Int

比较序列的长度和参数 len，返回序列的长度 - len

val a = Array(1,2,3,4)
println(a.lengthCompare(3))  //1
println(a.lengthCompare(4))  //0

map

def map[B](f: (A) ⇒ B): Array[B]

对序列中的元素进行 f 操作，返回生成的新序列

val a = Array(1,2,3,4)
val b = a.map(x=>x*10)
println(b.mkString(","))  //10,20,30,40

max

def max: A

返回序列中最大的元素

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

maxBy

def maxBy[B](f: (A) ⇒ B): A

返回序列中符合条件的第一个元素

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

min

def max: A

返回序列中最小的元素

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

minBy

def minBy[B](f: (A) ⇒ B): A

返回序列中不符合条件的第一个元素

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

mkString

def mkString: String

将序列中所有元素拼接成一个字符串

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

mkString(sep)

def mkString: String

将序列中所有元素拼接成一个字符串，以 sep 作为元素间的分隔符

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

mkString(start,sep,end)

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

将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

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

nonEmpty

def nonEmpty: Boolean

判断序列是否不为空

val a = Array(1,2,3,4)
val b = new Array[Int](0)
println(a.nonEmpty)  //true
println(b.nonEmpty)  //false

padTo

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

填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

val a = Array(1,2,3,4)
val b = a.padTo(7,8)
println(b.mkString(",")) //1,2,3,4,8,8,8
val c = a.padTo(3,8)
println(c.mkString(",")) //1,2,3,4

par

def par: ParArray[T]

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

val a = Array(1,2,3,4)
//b: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4)
val b = a.par
println(b.mkString(","))  //1,2,3,4

partition

def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])

按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

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

patch

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

批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that

val a = Array(1,2,3,4)
val b = Array(7,8,9)
val c = a.patch(1,b,2) //a索引1的元素开始，用b替换2个元素
println(c.mkString(",")) //1,7,8,9,4

permutations

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

permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合

val a = Array("a","b","c")
val b = a.permutations  //迭代器
b.foreach(x=>println(x.mkString(",")))

prefixLength

def prefixLength(p: (T) ⇒ Boolean): Int

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

val a = Array(1,2,3,4)
println(a.prefixLength(x=>x<3))   //2
val b = Array(5,1,2,3,4)
println(b.prefixLength(x=>x<3))  //0 如果第一个就不符合返回0

product

def product: A

返回所有元素乘积的值

val a = Array(1,2,3,4)
println(a.product)  //24

reduce

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

同 fold，不需要初始值

def seqno(m:Int,n:Int):Int={
  val s = "seq_exp = %d + %d"
  println(s.format(m,n))
  m + n
}
val a =Array(1,2,3,4)
val b = a.reduce(seqno)
println("b = "+b)

reduceLeft

def reduceLeft[B >: A](op: (B, T) ⇒ B): B

同 foldLeft，从左向右计算，不需要初始值

val a = Array(1,2,3,4)
val b = a.reduceLeft((x,y)=>{
  val s = "seq_exp = %d + %d"
  println(s.format(x,y))
  x + y
})
println("b = "+b)

reduceRight

def reduceRight[B >: A](op: (B, T) ⇒ B): B

同 foldRight，从右向左计算，不需要初始值

val a = Array(1,2,3,4)
val b = a.reduceRight((x,y)=>{
  val s = "seq_exp = %d + %d"
  println(s.format(x,y))
  x + y
})
println("b = "+b)

reduceLeftOption

def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]

同 reduceLeft，返回 Option

reduceRightOption

def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]

同 reduceRight，返回 Option

reverse

def reverse: Array[T]

反转序列

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

reverseIterator

def reverseIterator: collection.Iterator[T]
生成反向迭代器

val a = Array(1,2,3,4)
val b = a.reverseIterator
b.foreach(x=>print(x+" ")) //4 3 2 1

reverseMap

def reverseMap[B](f: (A) ⇒ B): Array[B]

同 map，方向相反

val a = Array(1,2,3,4)
val b = a.reverseMap(x=>x*10)
println(b.mkString(","))  //40,30,20,10

sameElements

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

判断两个序列是否顺序和对应位置上的元素都一样

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

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

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

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)
val b = a.scanRight(5)(_+_)
println(b.mkString(",")) //计算结果从右往左放15,14,12,9,5

segmentLength

def segmentLength(p: (T) ⇒ Boolean, from: Int): Int

从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个

val a = Array(1,2,3,1,1,1,4)
println(a.segmentLength(x=>x<3,3)) //从索引3开始查找 满足条件的连续元素有3个  3
println(a.segmentLength(x=>x<3,2)) //从索引2开始查找，第一个就不符合条件 返回0

seq

def seq: collection.mutable.IndexedSeq[T]

产生一个引用当前序列的 sequential 视图

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

size

def size: Int
返回序列元素个数，同 length

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

slice

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

返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

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

sliding(size)

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

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

val a = Array(1,2,3,4,5)
val b = a.sliding(3).toList//默认步长为1
for(i <- 0 to b.length - 1){
  val s = "第 %d 组: %s"
  println(s.format(i+1,b(i).mkString(",")))
}

sliding(size,step)

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

从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束。该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始

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

sortBy

def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]

按指定的排序规则对序列排序

val a = Array(3,2,4,1)
val b = a.sortBy(x=>x)
println("升序："+b.mkString(",")) //1,2,3,4
val c = a.sortBy(x=>0 - x)
println("降序："+c.mkString(",")) //4,3,2,1

sorted

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

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

val a = Array(3,2,4,1)
val b = a.sorted //默认升序排列
println(b.mkString(","))  //1,2,3,4

span

def span(p: (T) ⇒ Boolean): (Array[T], Array[T])

将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

val a = Array(1,2,3,4)
val b = a.span(x => x < 3)
println(b._1.mkString(",")) //1,2
println(b._2.mkString(",")) //3,4

splitAt

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

从指定位置开始，把序列拆分成两个数组

val a = Array(1,2,3,4)
val b = a.splitAt(1)
println(b._1.mkString(",")) //1
println(b._2.mkString(",")) //2,3,4

startsWith(that)

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

判断序列是否以某个序列开始

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

startsWith(that)

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

判断序列从指定偏移处是否以某个序列开始

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

stringPrefix

def stringPrefix: String

返回 toString 结果的前缀

val a = Array(1,2,3,4)
println(a.toString())  //[I@3a45c42a
pringln(a.stringPrefix)  //[I

subSequence

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

返回 start 和 end 间的字符序列，不包含 end 处的元素

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

sum

def sum: A

序列求和，元素需为 Numeric[T] 类型

val a = Array(1,2,3,4)
println(a.sum)  //10

tail

def tail: Array[T]

返回当前序列中不包含第一个元素的序列

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

tails

def tails: collection.Iterator[Array[T]]

同 inits，每一步都进行 tail 操作

val a = Array(1,2,3,4)
val b = a.tails.toList
for(i <- 0 to b.length - 1){
  val s = "第 %d 个值：%s"
  println(s.format(i+1,b(i).mkString(",")))
}

take

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

返回当前序列中，前 n 个元素组成的序列

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

takeRight

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

返回当前序列中，从右边开始，后 n 个元素组成的序列

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

takeWhile

def takeWhile(p: (T) ⇒ Boolean): Array[T]

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

val a = Array(1,2,3,4)
val b = a.takeWhile(x=>x<3)
println(b.mkString(","))  //1,2

toArray

def toArray: Array[A]

将序列转换成 Array 类型

toBuffer

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

将序列转换成 Buffer 类型

toIndexedSeq

def toIndexedSeq: collection.immutable.IndexedSeq[T]

将序列转换成 IndexedSeq 类型

toIterable

def toIterable: collection.Iterable[T]

将序列转换成可迭代的类型

toIterator

def toIterator: collection.Iterator[T]

将序列转换成迭代器，同 iterator 方法

toList

def toList: List[T]

将序列转换成 List 类型

toMap

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

将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型

toSeq

def toSeq: collection.Seq[T]

将序列转换成 Seq 类型

toSet

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

将序列转换成 Set 类型

toStream

def toStream: collection.immutable.Stream[T]

将序列转换成 Stream 类型

toVector

def toVector: Vector[T]

将序列转换成 Vector 类型

transpose

def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]

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

val a = Array(Array("a","b"),Array("c","d"),Array("e","f"))
//b: Array[Array[String]] = Array(Array(a, c, e), Array(b, d, f))
val b = a.transpose
b.foreach(x=>println(x.mkString(",")))
//a,c,e
//b,d,f

union

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

合并两个序列，同操作符 ++

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

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"))
val b = a.unzip
println(b._1.mkString(","))  //a,c
println(b._2.mkString(","))  //b,d

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","x"),("c","d","y"),("e","f","z"))
val b = a.unzip3
println(b._1.mkString(","))  //a,c,e

update

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

将序列中 i 索引处的元素更新为 x

val a = Array(1,2,3,4)
a.update(3,10)
println(a.mkString(","))  //1,2,3,10  //自身发生变化

updated

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

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

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

view

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

返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

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

withFilter

def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]

根据条件 p 过滤元素

val a = Array(1,2,3,4)
//scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@34d480b9
val b = a.withFilter(x=>x>2)
//Array[Int] = Array(3, 4)
val c = a.withFileter(x=>x>2).map(x=>x)
println(c.mkString(","))  //3,4

zip

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

将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同

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

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,6,7)
val b = Array(5,4,3,2,1)
val c = a.zipAll(b.8,9)  // (1,5),(2,4),(3,3),(4,2),(5,1),(6,9),(7,9)
println(c,mkString(","))
val d = Array(1,2,3,4)
val e = Array(6,5,4,3,2,1)
val f = d.zipAll(e,8,9)  // (1,6),(2,5),(3,4),(4,3),(8,2),(8,1)
println(c.mkString(","))

zipWithIndex

def zipWithIndex: Array[(A, Int)]

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

val a = Array('a','b','c','d')
val b = a.zipWithIndex
println(b.mkString(",")) // (a,0),(b,1),(c,2),(d,3) 
b.foreach(x=>println(x._2+","+x._1))