scala 数组函数大全（143个1个不漏，全面案例详解）

最新推荐文章于 2020-12-27 18:49:06 发布

BigData_Hubert

最新推荐文章于 2020-12-27 18:49:06 发布

阅读量3.5k

点赞数 6

分类专栏：大数据文章标签： scala scala array 数组函数大全数组方法大数据

本文链接：https://blog.csdn.net/BigData_Hobert/article/details/108437748

版权

大数据专栏收录该内容

25 篇文章 3 订阅

订阅专栏

scala系列

scala 数组函数大全

scala系列
前言
一、scala 数组简介
二、思维导图
三、数组函数汇总
四、数组函数详解

前言

本篇博客为大家带来的是 scala 所有（没错，没有看错，就是所有）数组函数的案例详解大全。scala的主要优势是它的表达性。没错,相比于java而言,scala可以用更少的代码"优雅"地表达出我们所想。所以,scala足以成为我们程序员必须涉猎的语言之一。scala 数组函数是 scala 能够实现代码飘逸的核心基础所在，因此在 scala 入门的时候必须强记下来，没有任何商量的余地。

相信大家在看完的数组函数汇总后，都能够代码敲的飘逸！“so easy”

在这里插入图片描述

一、scala 数组简介

数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示Java中的数组形式 T[]。

val numbers = Array(1, 2, 3, 4) //声明一个数组对象
val first = numbers(0) // 读取第一个元素
numbers(3) = 100 // 替换第四个元素为100
val biggerNumbers = numbers.map(_ * 2) // 所有元素乘2

查看方法：

在 window DOS 窗口，输入 scala 进入scala命令行
随意定义一个数组：val arr = Array(1,2,3,4)
输入： arr. + Tab 键即可显示scala所有数组、集合函数，如下图所示：

scala> val a = Array(1,2)
a: Array[Int] = Array(1, 2)

scala> a.
++              count            hasDefiniteSize      maxBy               sameElements    toBuffer
++:             deep             head                 min                 scan            toIndexedSeq
+:              diff             headOption           minBy               scanLeft        toIterable
/:              distinct         indexOf              mkString            scanRight       toIterator
:+              drop             indexOfSlice         nonEmpty            segmentLength   toList
:\              dropRight        indexWhere           orElse              seq             toMap
addString       dropWhile        indices              padTo               size            toSeq
aggregate       elemManifest     init                 par                 slice           toSet
andThen         elemTag          inits                partition           sliding         toStream
apply           endsWith         intersect            patch               sortBy          toTraversable
applyOrElse     exists           isDefinedAt          permutations        sortWith        toVector
array           filter           isEmpty              prefixLength        sorted          transform
canEqual        filterNot        isTraversableAgain   product             span            transpose
clone           find             iterator             reduce              splitAt         union
collect         flatMap          last                 reduceLeft          startsWith      unzip
collectFirst    flatten          lastIndexOf          reduceLeftOption    stringPrefix    unzip3
combinations    fold             lastIndexOfSlice     reduceOption        sum             update
companion       foldLeft         lastIndexWhere       reduceRight         tail            updated
compose         foldRight        lastOption           reduceRightOption   tails           view
contains        forall           length               repr                take            withFilter
containsSlice   foreach          lengthCompare        reverse             takeRight       zip
copyToArray     genericBuilder   lift                 reverseIterator     takeWhile       zipAll
copyToBuffer    groupBy          map                  reverseMap          to              zipWithIndex
corresponds     grouped          max                  runWith             toArray

scala> a.

数组的泛型：

[B>: A] 表示B 是A的超类
[B <: A] 表示B 是A的子类

二、思维导图

在这里插入图片描述

三、数组函数汇总

++	count	hasDefiniteSize	maxBy	sameElements	toBuffer
++:	deep	head	min	scan	toIndexedSeq
+:	diff	headOption	minBy	scanLeft	toIterable
/:	distinct	indexOf	mkString	scanRight	toIterator
:+	drop	indexOfSlice	nonEmpty	segmentLength	toList
:\	dropRight	indexWhere	orElse	seq	toMap
addString	dropWhile	indices	padTo	size	toSeq
aggregate	elemManifest	init	par	slice	toSet
andThen	elemTag	inits	partition	sliding	toStream
apply	endsWith	intersect	patch	sortBy	toTraversable
applyOrElse	exists	isDefinedAt	permutations	sortWith	toVector
array	filter	isEmpty	prefixLength	sorted	transform
canEqual	filterNot	isTraversableAgain	product	span	transpose
clone	find	iterator	reduce	splitAt	union
collect	flatMap	last	reduceLeft	startsWith	unzip
collectFirst	flatten	lastIndexOf	reduceLeftOption	stringPrefix	unzip3
combinations	fold	lastIndexOfSlice	reduceOption	sum	update
companion	foldLeft	lastIndexWhere	reduceRight	tail	updated
compose	foldRight	lastOption	reduceRightOption	tails	view
contains	forall	length	repr	take	withFilter
containsSlice	foreach	lengthCompare	reverse	takeRight	zip
copyToArray	genericBuilder	lift	reverseIterator	takeWhile	zipAll
copyToBuffer	groupBy	map	reverseMap	to	zipWithIndex
corresponds	grouped	max	runWith	toArray	subSequence

四、数组函数详解

方法名：++
源码定义：

 def ++[B >: A, That](that : scala.collection.GenTraversableOnce[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：合并两个序列(序列为空，必须指定泛型)，若序列类型不同以左边序列类型为主；若泛型类型不同以两个序列共同的最小父类为结果类型；结果元素是在A序列元素后面添加B序列的元素。

返回值：左边序列类型，最小父类序列泛型类型

示例：

scala> val a = Array(1,2)
a: Array[Int] = Array(1, 2)

scala> val b = Array("a",1)
b: Array[Any] = Array(a, 1)

scala> a ++ b
res103: Array[Any] = Array(1, 2, a, 1)

// 若泛型类型不同以两个序列共同的最小父类为结果类型
scala> val c = Array(1.0,2.3)
c: Array[Double] = Array(1.0, 2.3)

scala> a ++ c
res104: Array[AnyVal] = Array(1, 2, 1.0, 2.3)

scala> val d = List(1,2)
d: List[Int] = List(1, 2)

// 若序列类型不同以左边序列类型为主
scala> a ++ d
res1: Array[Int] = Array(1, 2, 1, 2)

scala> d ++ a
res2: List[Int] = List(1, 2, 1, 2)

方法名：++:
源码定义：

def ++:[B >: A, That](that : scala.collection.TraversableOnce[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：合并两个序列，若类型不同以右边类型为主。其他和 ++ 一样。
返回值：右边序列类型
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = Array(4,5,6)
b: Array[Int] = Array(4, 5, 6)

scala> val c = List(7,8,9)
c: List[Int] = List(7, 8, 9)

scala> val d = a ++: b
d: Array[Int] = Array(1, 2, 3, 4, 5, 6)

scala> val d = a ++: c
d: List[Int] = List(1, 2, 3, 7, 8, 9)

scala> val d = c ++: a
d: Array[Int] = Array(7, 8, 9, 1, 2, 3)

方法名：+:
源码定义：

def +:[B >: T](elem : B)(implicit evidence$3 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }

描述：在数组前面添加一个元素(添加的元素在前，就在数组头部添加，冒号要离数组近)，结果泛型类型取元素类型和数组类型的共同最小父类。
返回值：数组
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

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

scala> val b = "a" +: a
b: Array[Any] = Array(a, 1, 2, 3)

方法名：/:
源码定义：

def /:[B](z : B)(op : scala.Function2[B, A, B]) : B = { /* compiled code */ }

描述：对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写(冒号要离数组近)；相当于左二叉树。
返回值：计算结果
示例：

scala> val a = List(1, 2, 3, 4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (10 /: a) (_ + _) 		// (((10+1)+2)+3)+4
b: Int = 20

scala> val c = (10 /: a) (_ * _) 		// (((10*1)*2)*3)*4
c: Int = 240

scala> val d = ("a" /: a) (_ * _) 		// 1*2*3*4个a
d: String = aaaaaaaaaaaaaaaaaaaaaaaa

方法名：:+
源码定义：

 def :+[B >: T](elem : B)(implicit evidence$2 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }

描述：在数组后面添加一个元素(添加的元素在后，就在数组尾部添加，冒号要离数组近)；和 +: 相反
返回值：数组
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

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

方法名：:\
源码定义：

def :\[B](z : B)(op : scala.Function2[A, B, B]) : B = { /* compiled code */ }

描述：对数组中所有的元素从右向左遍历，进行相同的迭代操作，foldRight 的简写(冒号要离数组近)；相当于右二叉树。
返回值：计算结果
示例：

scala> val a = List(1, 2, 3, 4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (a :\ 10) (_ - _) 		// 1-(2-(3-(4-10)))
b: Int = 8

scala> val c = (a :\ 10) (_ * _) 		// 1*(2*(3*(4*10)))
c: Int = 240

scala> val d = (a \: "a") (_ + _) 		// 注意和 val d = ("a" /: a) (_ + _) 的区别
<console>:12: error: value \: is not a member of String
       val d = (a \: "a") (_ + _) // (((10*1)*2)*3)*4

方法名：addString
源码定义：

def addString(b : scala.StringBuilder, start : scala.Predef.String, sep : scala.Predef.String, end : scala.Predef.String) : scala.StringBuilder = { /* compiled code */ }
def addString(b : scala.StringBuilder, sep : scala.Predef.String) : scala.StringBuilder = { /* compiled code */ }
def addString(b : scala.StringBuilder) : scala.StringBuilder = { /* compiled code */ }

描述：将数组中的元素逐个添加到StringBuilder中
返回值： StringBuilder
示例：

scala> var a = new StringBuilder()
a: StringBuilder =

scala> val b = Array(1,2,3)
b: Array[Int] = Array(1, 2, 3)

//def addString(b: StringBuilder): StringBuilder 		将数组中的元素逐个添加到b中
scala> b.addString(a)
res3: StringBuilder = 123

scala> var a = new StringBuilder()
a: StringBuilder =

//def addString(b: StringBuilder, sep: String): StringBuilder 		将数组中的元素逐个添加到b中，每个元素用sep分隔符分开
scala> b.addString(a,",")
res5: StringBuilder = 1,2,3

scala> var a = new StringBuilder()
a: StringBuilder =

//def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder 		将数组中的元素逐个添加到b中，在首尾各加一个字符串，并指定sep分隔符
scala> b.addString(a,"{",",","}")
res6: StringBuilder = {1,2,3}

方法名：aggregate
源码定义：

def aggregate[B](z : => B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B = { /* compiled code */ }

描述：aggregate是柯里化方法（将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数）， aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
  val s = "seq_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def combine(m: Int, n: Int): Int = {
  val s = "com_exp = %d + %d"
  println(s.format(m, n))
  m + n
}

def main(args: Array[String]) {
  val a = List(1, 2, 3, 4)

  val b = a.aggregate(5)(seqno, combine) 		// 不分区
  println("b = " + b)
  /*
   * seq_exp = 5 + 1
   * seq_exp = 6 + 2
   * seq_exp = 8 + 3
   * seq_exp = 11 + 4
   * b = 15
   */
   
   // List元素数量为偶数
  val c = a.par.aggregate(5)(seqno, combine) 		// 分区
  println("c = " + c)
  /*
   * 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 d = List(1, 2, 3)
  // List元素数量为奇数
  val e = a.par.aggregate(5)(seqno, combine) 		// 分区
  println("c = " + c)
  /*
   * seq_exp = 5 + 3
   * seq_exp = 5 + 2
   * seq_exp = 5 + 1
   * com_exp = 6 + 7
   * com_exp = 8 + 13
   * c = 21
   */
}

方法名：andThen
源码定义：

override def andThen[C](k : scala.Function1[B, C]) : scala.PartialFunction[A, C] = { /* compiled code */ }

描述：表示方法的连续调用，相当于嵌套函数 g(f(x)) （需满足第一个函数的返回值类型是第二个函数的输入值类型），与 compose 相反。
返回值：
示例：

def f(a:Int) = {
 println("2*"+a)
 2*a
}

def g(b:Int) = {
 println("3*"+b)
 3*b
}

def  result1 = f _ andThen g _
println(result1(1))
/*
2*1
3*2
6
*/
def  result2 = f _ compose  g _
println(result2(1))
/*
3*1
2*3
6
*/

方法名：apply
源码定义：

 def apply(i : scala.Int) : T = { /* compiled code */ }

描述：按下标取数组数据
返回值：数组中的元素类型
示例：

scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.apply(2)  				//等同于直接写a(2)
res14: Int = 3

scala> a(2)
res15: Int = 3

方法名：applyOrElse
源码定义：

 def applyOrElse[A1 <: A, B1 >: B](x : A1, default : scala.Function1[A1, B1]) : B1 = { /* compiled code */ }

描述：接收2个参数，第一个是调用的参数，第二个是个回调函数。如果第一个调用的参数匹配，返回匹配的值，否则调用回调函数。（回调函数的输入类型需与调用参数类型一致），就相当于if-else分支调用函数。
返回值：
示例：

scala> val pf1:PartialFunction[Int,String] = {   		//定义一个偏函数，输入 1 返回 "one"
     | case i if i == 1 => "One"
     | }
pf1: PartialFunction[Int,String] = <function1>

scala> pf1.applyOrElse(1,{num:Int=>"two"})  		//输入1匹配到"one"
res16: String = One

scala> pf1.applyOrElse(2,{num:Int=>"two"})  		//输入2匹配失败则触发回调函数，返回 "Two" 字符串
res17: String = two

方法名：array
描述： Array是scala中数组是用来存储同类型的元素结构，数组中本身size不可变，但是数组中元素可变，可重新赋值
返回值：
示例：

//声明一个String类型的数组
scala> var arr:Array[String] = new Array[String](3)  		//长度为3，未赋值：null  null null
arr: Array[String] = Array(null, null, null)

scala> var arr = new Array[String](3)  						//长度为3，未赋值：null  null null
arr: Array[String] = Array(null, null, null)

scala> var arr1 = Array("java","scala","python")   			//长度为3，赋值："java","scala","python"
arr1: Array[String] = Array(java, scala, python)

//添加、修改元素
scala> arr(0) = "java"

scala> arr(1) = "scala"

scala> arr(2) = "python"

//索引
scala> arr(0)
res21: String = java

scala> arr(1)
res22: String = scala

scala> arr(2)
res23: String = python

//遍历打印
scala> arr.foreach(println)
java
scala
python

方法名：canEqual
源码定义：

override def canEqual(that : scala.Any) : scala.Boolean = { /* compiled code */ }

描述：判断两个对象是否可以进行比较(基本上都可以比较)
返回值： boolean
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)

scala> val c = "hello"
c: String = hello

scala> val d = 5
d: Int = 5

scala> a.canEqual(b)
res25: Boolean = true

scala> a.canEqual(c)
res26: Boolean = true

scala> a.canEqual(d)
res27: Boolean = true

方法名：clone
源码定义：

override def clone() : scala.Array[T] = { /* compiled code */ }

描述：创建一个数组的副本，复制数组的值,但不会引用地址；就是说是浅克隆，不是深克隆。
返回值：数组
示例：

scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = Array(4,5,a)
b: Array[Any] = Array(4, 5, Array(1, 2, 3))

scala> val c = b.clone()
c: Array[Any] = Array(4, 5, Array(1, 2, 3))

scala> c(2).asInstanceOf[Array[Int]](0) = 5

scala> a
res43: Array[Int] = Array(5, 2, 3)

scala> c
res44: Array[Any] = Array(4, 5, Array(5, 2, 3))

方法名：collect
源码定义：

 def collect[B, That](pf : scala.PartialFunction[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：输入参数类型为偏函数，对序列中的元素进行转换（通过执行一个并行计算（偏函数），得到一个新的数组对象）
返回值：
示例：

scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val fun:PartialFunction[Int,Int]={
     | case x if x%2==0 => x+2
     | case x => x+1
     | }
fun: PartialFunction[Int,Int] = <function1>

scala> a.collect(fun)
res45: Array[Int] = Array(2, 4, 4, 6)

scala> val fun:PartialFunction[Int,Int]={
     | case x if x%2==0 => x+2
     | case _ => 1
     | }
fun: PartialFunction[Int,Int] = <function1>

scala> a.collect(fun)
res46: Array[Int] = Array(1, 4, 1, 6)

方法名：collectFirst
源码定义：

 def collectFirst[B](pf : scala.PartialFunction[A, B]) : scala.Option[B] = { /* compiled code */ }

描述：查找序列中第一个符合偏函数的元素执行相应操作
返回值： Option类型
示例：定义一个偏函数，当被执行对象为 int类型时，执行+1

// 方法一
scala> val fun: PartialFunction[Any, Int] = {
     |   case x: Int => x + 1
     | }
fun: PartialFunction[Any,Int] = <function1>

scala> val a = Array('a',1,3, "A")
a: Array[Any] = Array(a, 1, 3, A)

scala> val b = a.collectFirst(fun)
b: Option[Int] = Some(2)

scala> b.get
res48: Int = 2

// 方法二
scala> a.collectFirst({case x: Int => x + 1}).get
res49: Int = 2

方法名：combinations
源码定义：

def combinations(n : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：排列组合l列出所有包含字符不一样的组合，不考虑顺序，参数n表示每个组合的序列长度。(如对于 “ab”、“ba”，视为相同组合)
返回值：
示例：

scala> val a = Array("a", "b", "c")
a: Array[String] = Array(a, b, c)

scala> val b = a.combinations(2)
b: Iterator[Array[String]] = non-empty iterator

scala> b.foreach(x => println(x.mkString(",")))
a,b
a,c
b,c

方法名：companion
源码定义：

override def companion : scala.collection.generic.GenericCompanion[scala.collection.mutable.IndexedSeq] = { /* compiled code */ }

描述：伴生对象
返回值：
示例：

方法名：compose
源码定义：

def compose[A](g : scala.Function1[A, T1]) : scala.Function1[A, R] = { /* compiled code */ }

描述：表示方法的连续调用，与 andThen 相反，不同的是需满足第二个函数的返回值类型是第一个函数的输入值类型
返回值：
示例：

scala> def f(a:Int) = {
     |  println("2*"+a)
     |  2*a
     | }
f: (a: Int)Int

scala>

scala> def g(b:Int) = {
     |  println("3*"+b)
     |  3*b
     | }
g: (b: Int)Int

scala>

scala> def  result1 = f _ andThen g _
result1: Int => Int

scala> println(result1(1))
2*1
3*2
6

scala> def  result2 = f _ compose  g _
result2: Int => Int

scala> println(result2(1))
3*1
2*3
6

方法名：contains
源码定义：

override def contains[A1 >: A](elem : A1) : scala.Boolean = { /* compiled code */ }

描述：判断序列中是否包含指定对象
返回值：Boolean
示例：

scala> val a = List(1, 2, 3, 4)
a: List[Int] = List(1, 2, 3, 4)

scala> println(a.contains(1)) 
true

方法名：containsSlice
源码定义：

def containsSlice[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }

描述：判断当前序列中是否包含另一个序列（数量和顺序相等）
返回值：Boolean
示例：

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

scala> val b = Array(1,2,3,Array(4,5))
b: Array[Any] = Array(1, 2, 3, Array(4, 5))

scala> val c =Array(4,5,6)
c: Array[Int] = Array(4, 5, 6)

scala> b.containsSlice(c)
res16: Boolean = false

scala> val c =Array(4,5)
c: Array[Int] = Array(4, 5)

scala> b.containsSlice(c)
res17: Boolean = false

scala> val d = Array(1,2,3,4,5)
d: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val c = Array(5,4)
c: Array[Int] = Array(5, 4)

scala>  d.containsSlice(c)
res70: Boolean = false

方法名：copyToArray
源码定义：

def copyToArray[B >: A](xs : scala.Array[B], start : scala.Int) : scala.Unit = { /* compiled code */ }
def copyToArray[B >: A](xs : scala.Array[B]) : scala.Unit = { /* compiled code */ }

描述：将当前数组元素复制到另一个数组中(可以指定起始下标引入，选择引入几个元素)
返回值：
示例：

val a = Array(1, 2, 3)
val b: Array[Int] = new Array(10)
a.copyToArray(b)
println(b.mkString(",")) 		// 1,2,3,0,0,0,0,0,0,0
a.copyToArray(b, 4, 2) 			//从5位引入2个数字
println(b.mkString(",")) 		// 1,2,3,0,1,2,0,0,0,0

方法名：copyToBuffer
源码定义：

def copyToBuffer[B >: A](dest : scala.collection.mutable.Buffer[B]) : scala.Unit = { /* compiled code */ }

描述：将数组中的元素复制到 Buffer 中
返回值：
示例：

//需先引入ArrayBuffer jar包
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b: ArrayBuffer[Int] = ArrayBuffer()
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> a.copyToBuffer(b)

scala> println(b.mkString(","))
1,2,3,4

方法名：corresponds
源码定义：

def corresponds[B](that : scala.collection.GenSeq[B])(p : scala.Function2[A, B, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

描述：判断两个序列的长度以及对应位置元素是否符合某个条件，满足返回true，不满足返回false
返回值：Boolean
示例：

// 下面代码检查 a 和 b、c长度是否相等，并且 a 中元素是否都小于 b、c 中对应位置的元素
val a = Array(1, 2, 3, 4)
val b = Array(5, 6, 7, 8)
val c = Array(2, 1, 4, 5)
println(a.corresponds(b)(_ < _)) 		// true
println(a.corresponds(c)(_ < _)) 		// false

方法名：count
源码定义：

def count(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

描述：统计符合条件的元素个数
返回值：
示例：

// 下面代码统计数组中大于 2 的元素个数
scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> println(a.count(x => x > 2)) 
2

方法名：deep
源码定义：

def deep : scala.collection.IndexedSeq[scala.Any] = { /* compiled code */ }

描述：
返回值：
示例：

方法名：diff
源码定义：

def diff[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }

描述：计算当前数组与另一个数组的差集，即返回另外一个数组中没有的元素
返回值：数组
示例：

scala> val a = Array(1, 2, 2, 3, 4,4)
a: Array[Int] = Array(1, 2, 2, 3, 4, 4)

scala> val b = Array(3, 4, 5, 6,3)
b: Array[Int] = Array(3, 4, 5, 6, 3)

scala> val c = a.diff(b)
c: Array[Int] = Array(1, 2, 2, 4)

scala> println(c.mkString(","))
1,2,2,4

方法名：distinct
源码定义：

def distinct : Repr = { /* compiled code */ }

描述：去除当前集合中重复的元素，只保留一个
返回值：数组
示例：

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

方法名：drop
源码定义：

override def drop(n : scala.Int) : Repr = { /* compiled code */ }

描述：删除数组中前 n 个元素
返回值：数组
示例：

val a = Array(1, 2, 3, 4)
val b = a.drop(2)   			 //删除前两个元素
println(b.mkString(","))		 // 3,4

方法名：dropRight
源码定义：

override def dropRight(n : scala.Int) : Repr = { /* compiled code */ }

描述：删除数组中尾部的 n 个元素
返回值：数组
示例：

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

方法名：dropWhile
源码定义：

override def dropWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述：删除数组中符合条件的元素，从第一个元素起，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），若第一个条件就不满足就返回整个数组
返回值：数组
示例：

val a = Array(1,2,3,4,3,2,1)
val b = a.dropWhile(x => x < 3)  			//删除小于3的元素
println(b.mkString(",")) 					// 3,4,3,2,1   遇到4截止
val b = a.dropWhile(x => x > 2)
println(b.mkString(",")) 					// 1,2,3,4,3,2,1  第一个条件就不满足，返回整个数组

方法名：elemManifest
源码定义：

描述：
返回值：
示例：

方法名：elemTag
源码定义：

描述：
返回值：
示例：
方法名：endsWith
源码定义：

override def endsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }

描述：判断当前序列是否以某个序列结尾
返回值：Boolean
示例：

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

方法名：exists
源码定义：

override def exists(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

描述：判断当前数组是否包含符合条件的元素
返回值： Boolean
示例：

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

方法名：filter
源码定义：

def filter(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述：筛选数组中符合条件的元素
返回值：数组
示例：

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

方法名：filterNot
源码定义：

def filterNot(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

描述：与filter相反，将不满足条件的元素筛选出来
返回值：
示例：

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

方法名：find
源码定义：

override def find(p : scala.Function1[A, scala.Boolean]) : scala.Option[A] = { /* compiled code */ }

描述：查找第一个符合条件的元素
返回值： Option
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.find(x => x > 2).get
res92: Int = 3

方法名：flatMap
源码定义：

def flatMap[B, That](f : scala.Function1[A, scala.collection.GenTraversableOnce[B]])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述： flatMap = map + flatten 即先对集合中的每个元素进行map，再对map后的每个元素（map后的每个元素必须还是集合）中的每个元素进行flatten。参数要求是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

//与map的区别
val c = a.map(x => 1 to x)
println(c.mkString(","))  //分别返回4个数组  Range(1),Range(1, 2),Range(1, 2, 3),Range(1, 2, 3, 4)

//展开一个Array[Array]类型的数组
val arr = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9))
val ints = arr.flatMap(x => x)
println(ints.mkString(","))  //展开arr中每一个数组元素  1,2,3,4,5,6,7,8,9

方法名：flatten
源码定义：

 def flatten[U](implicit asTrav : scala.Function1[T, scala.collection.Traversable[U]], m : scala.reflect.ClassTag[U]) : scala.Array[U] = { /* compiled code */ }

描述：扁平化操作，通常配合map使用；将二维数组的所有元素联合在一起，形成一个一维数组返回。
返回值：序列
示例：

// 降维
scala> val arr = Array("java python scala ", "math English chinese")
arr: Array[String] = Array("java python scala ", math English chinese)

scala> arr.map(_.split(" ")).flatten
res103: Array[String] = Array(java, python, scala, math, English, chinese)

// 序列的元素必须是 相同维度的序列
scala> val a = Array(1,Array(1,3))
a: Array[Any] = Array(1, Array(1, 3))

scala> a.flatten
<console>:14: error: No implicit view available from Any => Traversable[U].
       a.flatten
         ^
// 一次只能降一维
scala> val b = Array(Array(1,2,Array(1,2)),Array(3,4,Array(1,5)))
b: Array[Array[Any]] = Array(Array(1, 2, Array(1, 2)), Array(3, 4, Array(1, 5)))

scala> b.flatten
res105: Array[Any] = Array(1, 2, Array(1, 2), 3, 4, Array(1, 5))

// 一维不能再降
scala> val c = Array(0,1)
c: Array[Int] = Array(0, 1)

scala> c.flatten
<console>:14: error: No implicit view available from Int => Traversable[U].
       c.flatten

方法名：fold
源码定义：

def fold[A1 >: A](z : A1)(op : scala.Function2[A1, A1, A1]) : A1 = { /* compiled code */ }

描述：从左到右计算，对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
返回值：
示例：

  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进行处理。

方法名：foldLeft
源码定义：

def foldLeft[S](z : S)(op : scala.Function2[S, T, S]) : S = { /* compiled code */ }

描述：同 fold，但是foldLeft使用分区并行计算没有效果；从左到右计算，简写方式：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))
  m + n
}

def main(args: Array[String]): Unit = {
  val a = Array(1, 2, 3, 4)

  val b = a.foldLeft(5)(seqno) // 简写: (5 /: a)(_ + _)
  println("b = " + b)
  /*
   * seq_exp = 5 + 1
   * seq_exp = 6 + 2
   * seq_exp = 8 + 3
   * seq_exp = 11 + 4
   * b = 15
   */ 
  val c = a.par.foldLeft(5)(seqno) // 分区
  println("c = " + c)
   /*
   * seq_exp = 5 + 1
   * seq_exp = 6 + 2
   * seq_exp = 8 + 3
   * seq_exp = 11 + 4
   * c = 15
   */
}

方法名：foldRight
源码定义：

def foldRight[S](z : S)(op : scala.Function2[T, S, S]) : S = { /* compiled code */ }

描述：从右到左计算，与foldLeft相反；从右到左计算，简写方式：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))
  m + n
}

def main(args: Array[String]): Unit = {
  val a = Array(1, 2, 3, 4)

  val b = a.foldRight(5)(seqno) // 简写: (a :\ 5)(_ + _)
  println("b = " + b)
  /*
   * seq_exp = 4 + 5
   * seq_exp = 3 + 9
   * seq_exp = 2 + 12
   * seq_exp = 1 + 14
   * b = 15
   */
  val c = a.par.foldRight(5)(seqno) // 分区
  println("c = " + c)
   /*
   * seq_exp = 4 + 5
   * seq_exp = 3 + 9
   * seq_exp = 2 + 12
   * seq_exp = 1 + 14
   * c = 15
   */
}

方法名：forall
源码定义：

override def forall(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }

描述：检测序列中的元素是否都满足条件 p，满足则返回true
返回值： boolean
示例：

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

方法名：foreach
源码定义：

override def foreach[U](f : scala.Function1[A, U]) : scala.Unit = { /* compiled code */ }

描述：遍历序列中的元素
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.foreach(x => println(x * 10))
10
20
30
40

方法名：genericBuilder
源码定义：

def genericBuilder[B] : scala.collection.mutable.Builder[B, CC[B]] = { /* compiled code */ }

描述：
返回值：
示例：

方法名：groupBy
源码定义：

def groupBy[K](f : scala.Function1[A, K]) : scala.collection.immutable.Map[K, Repr] = { /* compiled code */ }

描述：按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
返回值：Map
示例：

//  把数组中的元素按奇数和偶数分成两组，返回 Map[String, Array[Int]]
scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b = a.groupBy(x => x match {case x if (x%2 == 0) => "odd" case _=> "even"})
b: scala.collection.immutable.Map[String,Array[Int]] = Map(odd -> Array(2), even -> Array(1, 3))

scala> b.foreach(x => println(x._1 + ": " + x._2.mkString(",")))
odd: 2
even: 1,3

scala> b.apply("odd")
res1: Array[Int] = Array(2)

scala> b.get("odd").get
res3: Array[Int] = Array(2)

scala> val words = Array("hello world","hello scala","spark scala")
words: Array[String] = Array(hello world, hello scala, spark scala)

scala> words.flatMap(_.split(" ")).groupBy(x => x).foreach(f=>println(f._1,f._2.length))
(spark,1)
(scala,2)
(world,1)
(hello,2)

方法名：grouped
源码定义：

def grouped(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：按指定数量分组，每组有 size 个元素，当指定数量超出数组元素的长度时，分为一组
返回值： Iterator
示例：

scala> val a = Array(1, 2, 3, 4, 5)
a: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val b = a.grouped(3).toList
b: List[Array[Int]] = List(Array(1, 2, 3), Array(4, 5))

scala> b.foreach(x => println("第 " + (b.indexOf(x) + 1) + " 组: " + x.mkString(",")))
第 1 组: 1,2,3
第 2 组: 4,5

scala> val c = a.grouped(6).toList
c: List[Array[Int]] = List(Array(1, 2, 3, 4, 5))

scala> c.foreach(x => println("第 " + (c.indexOf(x) + 1) + " 组: " + x.mkString(",")))
第 1 组: 1,2,3,4,5

方法名：hasDefiniteSize
源码定义：

def hasDefiniteSize : scala.Boolean = { /* compiled code */ }

描述：检测序列是否存在有限的长度，对应 Stream 类型的流数据则返回 false
返回值： boolean
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.hasDefiniteSize 
res22: Boolean = true

scala> a.toStream.hasDefiniteSize
res23: Boolean = false

方法名：head
源码定义：

override def head : A = { /* compiled code */ }

描述：返回序列的第一个元素，如果序列为空会报错
返回值：
示例：

scala> a
res25: Array[Int] = Array(1, 2, 3, 4)

scala> a.head
res26: Int = 1

scala> val b = Array[String]()
b: Array[String] = Array()

scala> b.head
java.util.NoSuchElementException: next on empty iterator
  at scala.collection.Iterator$$anon$2.next(Iterator.scala:39)
  at scala.collection.Iterator$$anon$2.next(Iterator.scala:37)
  at scala.collection.IndexedSeqLike$Elements.next(IndexedSeqLike.scala:63)
  at scala.collection.IterableLike$class.head(IterableLike.scala:107)
  at scala.collection.mutable.ArrayOps$ofRef.scala$collection$IndexedSeqOptimized$$super$head(ArrayOps.scala:186)
  at scala.collection.IndexedSeqOptimized$class.head(IndexedSeqOptimized.scala:126)
  at scala.collection.mutable.ArrayOps$ofRef.head(ArrayOps.scala:186)
  ... 32 elided

方法名：headOption
源码定义：

def headOption : scala.Option[A] = { /* compiled code */ }

描述：返回序列的第一个元素的 Option 类型对象，就是scala.Some 或者 None，如果序列为空，则返回 None
返回值： Option
示例：

scala> a
res28: Array[Int] = Array(1, 2, 3, 4)

scala> a.headOption
res29: Option[Int] = Some(1)

scala> b
res30: Array[String] = Array()

scala> b.headOption
res31: Option[String] = None

方法名：indexOf
源码定义：

def indexOf[B >: A](elem : B) : scala.Int = { /* compiled code */ }

描述：返回元素 elem 在序列中第一次出现的索引，也可以指定索引（包括）from从左向右开始查找，找不到返回-1；并且指定索引可以超出元素索引的范围
返回值：索引值
示例：

scala> a
res32: Array[Int] = Array(1, 2, 3, 4)

scala> a.indexOf(4)
res34: Int = 3

scala> val a = Array(1, 3, 2, 3, 4)
a: Array[Int] = Array(1, 3, 2, 3, 4)

// 返回elem在序列中的索引，可以指定从某个索引（包括）处（from）开始查找，找到第一个就返回
scala> a.indexOf(3,2)
res35: Int = 3

方法名：indexOfSlice
源码定义：

def indexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }
def indexOfSlice[B >: A](that : scala.collection.GenSeq[B], from : scala.Int) : scala.Int = { /* compiled code */ }

描述：检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引(可以指定从索引 from 开始查找，并返回第一次出现该序列的索引)
返回值：索引值
示例：

scala> val a = Array(1,2,3,4,5,2,3,6,7,2,3)
a: Array[Int] = Array(1, 2, 3, 4, 5, 2, 3, 6, 7, 2, 3)

scala> val b = Array(2, 3)
b: Array[Int] = Array(2, 3)

scala> println(a.indexOfSlice(b)) 
1

scala> println(a.indexOfSlice(b,3)) 
5

方法名：indexWhere
源码定义：

def indexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

描述：返回当前序列中第一个满足条件 p 的元素的索引,可以指定从索引 from 开始查找
返回值：索引值
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> a.indexWhere(_>2)
res46: Int = 2

scala> a.indexWhere(_>2,3)
res47: Int = 3

方法名：indices
源码定义：

def indices : scala.collection.immutable.Range = { /* compiled code */ }

描述：返回当前序列索引集合
返回值： Range
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.indices
b: scala.collection.immutable.Range = Range(0, 1, 2, 3)

方法名：init
源码定义：

override def init : Repr = { /* compiled code */ }

描述：返回当前序列中不包含最后一个元素的序列
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.init
b: Array[Int] = Array(1, 2, 3)

方法名：inits
源码定义：

def inits : scala.collection.Iterator[Repr] = { /* compiled code */ }

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

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.inits.toList
b: List[Array[Int]] = List(Array(1, 2, 3, 4), Array(1, 2, 3), Array(1, 2), Array(1), Array())

方法名：intersect
源码定义：

def intersect[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }

描述：取两个集合的交集
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = Array(3, 4, 5, 6)
b: Array[Int] = Array(3, 4, 5, 6)

scala> val c = a.intersect(b)
c: Array[Int] = Array(3, 4)

scala> Array(1,1,2,2,3,3).intersect(Array(1,4,3))
res56: Array[Int] = Array(1, 3)

方法名：isDefinedAt
源码定义：

def isDefinedAt(idx : scala.Int) : scala.Boolean = { /* compiled code */ }

描述：判断序列中是否存在指定索引
返回值： boolean
示例：

scala>     val a = Array(1, 2, 3, 4, 5)
a: Array[Int] = Array(1, 2, 3, 4, 5)

scala>     println(a.isDefinedAt(1))  
true

scala>     println(a.isDefinedAt(10)) 
false

方法名：isEmpty
源码定义：

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

描述：判断序列是否为空
返回值：
示例：

方法名：isTraversableAgain
源码定义：

final def isTraversableAgain : scala.Boolean = { /* compiled code */ }

描述：判断序列是否可以反复遍历，该方法是 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
源码定义：

override def iterator : scala.collection.Iterator[A] = { /* compiled code */ }

描述：生成当前序列的迭代器
返回值：
示例：

scala> b
res64: scala.collection.immutable.Map[String,Array[Int]] = Map(odd -> Array(2), even -> Array(1, 3))

scala> b.iterator.foreach(x=>println(x._1,x._2))
(odd,[I@1837799a)
(even,[I@482c8df9)

scala> b.iterator.foreach(x=>println(x._1,x._2.mkString(",")))
(odd,2)
(even,1,3)

方法名：last
源码定义：

override def last : A = { /* compiled code */ }

描述：返回序列的最后一个元素，如果序列为空，将引发错误
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> println(a.last) 
4

方法名：lastIndexOf
源码定义：

def indexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }
def indexOfSlice[B >: A](that : scala.collection.GenSeq[B], from : scala.Int) : scala.Int = { /* compiled code */ }

描述：返回元素 elem 在序列中最后一次出现的索引 (返回元素 elem 在序列中最后一次出现的索引，然后往左向右到指定索引遍历查找)
返回值：
示例：

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

方法名：lastIndexOfSlice
源码定义：

def lastIndexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }
def lastIndexOfSlice[B >: A](that : scala.collection.GenSeq[B], end : scala.Int) : scala.Int = { /* compiled code */ }

描述：检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引 (可以指定索引，往左向右到指定索遍历查找)，注意序列的查找以序列第一个元素为准
返回值：
示例：

scala> val a = Array(1, 2, 3, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 2, 3, 4)

scala> val b = Array(2, 3)
b: Array[Int] = Array(2, 3)

scala> println(a.lastIndexOfSlice(b))    
3

scala> println(a.lastIndexOfSlice(b, 2)) 
1

scala> println(a.lastIndexOfSlice(b, 1)) 
1

scala> println(a.lastIndexOfSlice(b, 0)) 
-1

方法名：lastIndexWhere
源码定义：

def lastIndexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }
def lastIndexWhere(p : scala.Function1[A, scala.Boolean], end : scala.Int) : scala.Int

描述：返回当前序列中最后一个满足条件 p 的元素的索引 (可以指定索引，往前查找)
返回值：
示例：

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

方法名：lastOption
源码定义：

def lastOption : scala.Option[A] = { /* compiled code */ }

描述：返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
返回值： Option
示例：

scala> a
res86: Array[Int] = Array(1, 2, 3, 4)

scala> a.lastOption
res87: Option[Int] = Some(4)

scala> val b = Array[Int]()
b: Array[Int] = Array()

scala> b.lastOption
res89: Option[Int] = None

方法名：length
源码定义：

def length : scala.Int = { /* compiled code */ }

描述：返回序列元素个数
返回值：
示例：

方法名：lengthCompare
源码定义：

override def lengthCompare(len : scala.Int) : scala.Int = { /* compiled code */ }

描述：比较序列的长度和参数 len，返回序列的长度 - len
返回值：
示例：

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

方法名：lift
源码定义：

描述：
返回值：
示例：

方法名：map
源码定义：

def map[B, That](f : scala.Function1[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：对序列中的元素进行 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[B >: A](implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述：返回序列中最大的元素
返回值：
示例：

scala> val b = Array(1,2,3,3)
b: Array[Int] = Array(1, 2, 3, 3)

scala> b.max
res93: Int = 3

方法名：maxBy
源码定义：

def maxBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述：返回序列中符合条件的第一个元素(找不到满足条件的元素返回一个元素)
返回值：
示例：

scala> b
res94: Array[Int] = Array(1, 2, 3, 3)

scala> b.maxBy(_>2)
res95: Int = 3

scala> b.maxBy(_>4)
res97: Int = 1

方法名：min
源码定义：

def min[B >: A](implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述：返回序列中最小的元素
返回值：
示例：

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

方法名：minBy
源码定义：

def minBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }

描述：返回序列中不符合条件的第一个元素(找不到满足条件的元素返回一个元素)
返回值：
示例：

scala> b
res98: Array[Int] = Array(1, 2, 3, 3)

scala> b.minBy(_<2)
res99: Int = 2

scala> b.minBy(_<0)
res100: Int = 1

方法名：mkString
源码定义：

def mkString(start : scala.Predef.String, sep : scala.Predef.String, end : scala.Predef.String) : scala.Predef.String = { /* compiled code */ }

描述：将序列中所有元素拼接成一个字符串，可以设置参数：mkString(start, sep, end) 将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾)
返回值：
示例：

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

方法名：nonEmpty
源码定义：

def nonEmpty : scala.Boolean = { /* compiled code */ }

描述：判断序列是否不为空
返回值： boolean
示例：

scala> a
res107: Array[Int] = Array(1, 2, 3, 4)

scala> a.nonEmpty
res108: Boolean = true

scala> val b = Array[String]()
b: Array[String] = Array()

scala> b.nonEmpty
res109: Boolean = false

方法名：orElse
源码定义：

final def orElse[B >: A](alternative : => scala.Option[B]) : scala.Option[B] = { /* compiled code */ }

描述：与 getOrElse(value) 类似，只不过 orElse 参数为Some，返回Option里的Some或从参数传递进去的Some
返回值： Option
示例：

scala> val a = Some("Hello Option")
a: Some[String] = Some(Hello Option)

scala> a.orElse(null)  //返回option的Some
res110: Option[String] = Some(Hello Option)

scala> val b = None
b: None.type = None

scala> b.orElse(Some("New Value"))  //返回参数的Some
res111: Option[String] = Some(New Value)

方法名：padTo
源码定义：

def padTo[B >: A, That](len : scala.Int, elem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

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

val a = Array(1, 2, 3, 4)
val b = a.padTo(7, 8)  //填充一个长度为 7 的序列，不足位补 8
println(b.mkString(",")) // 1,2,3,4,8,8,8
val c = a.padTo(3, 5)  //填充序列长度3，不足位补5
println(c.mkString(","))  //1,2,3,4

方法名：par
源码定义：

override def par : scala.collection.parallel.mutable.ParArray[T] = { /* compiled code */ }

描述：开启分区，并行执行任务
返回值：
示例：

scala> val a = Array(1, 2, 3, 4, 5)
a: Array[Int] = Array(1, 2, 3, 4, 5)

scala> a.foreach(print)  
12345

scala> a.par.foreach(print) 
54231

//获取参与执行任务的线程
scala> (0 to 10000).collect{case _ => Thread.currentThread.getName}.distinct
res115: scala.collection.immutable.IndexedSeq[String] = Vector(main)

//获取并行参与执行任务的线程
scala> (0 to 10000).par.collect{case _ => Thread.currentThread.getName}.distinct
res116: scala.collection.parallel.immutable.ParSeq[String] = ParVector(ForkJoinPool-1-worker-29, ForkJoinPool-1-worker-13, ForkJoinPool-1-worker-7, ForkJoinPool-1-worker-21, ForkJoinPool-1-worker-25, ForkJoinPool-1-worker-23, ForkJoinPool-1-worker-27, ForkJoinPool-1-worker-3, ForkJoinPool-1-worker-17, ForkJoinPool-1-worker-9, ForkJoinPool-1-worker-11, ForkJoinPool-1-worker-31)

在这里插入图片描述

方法名：partition
源码定义：

def partition(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

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

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[B >: A, That](from : scala.Int, patch : scala.collection.GenSeq[B], replaced : scala.Int)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that
返回值：
示例：

//  从 a 的第二个元素开始，取两个元素，即 2 和 3 ，将这两个元素替换为序列 b
val a = Array(1, 2, 3, 4)
val b = Array(7, 8, 9)
val c = a.patch(1, b, 2)
println(c.mkString(",")) // 1,7,8,9,4

方法名：permutations
源码定义：

def permutations : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：排列组合会选出所有排列顺序不同的字符组合，与 combinations 不同的是，对于相同的字符组合，比如 “abc”、“cba”，视为不同的组合
返回值：
示例：

scala> val a = Array("a", "b", "c")
a: Array[String] = Array(a, b, c)

scala> val b = a.permutations.toList
b: List[Array[String]] = List(Array(a, b, c), Array(a, c, b), Array(b, a, c), Array(b, c, a), Array(c, a, b), Array(c, b, a))

scala> b.foreach( x => println(x.mkString(",")))
a,b,c
a,c,b
b,a,c
b,c,a
c,a,b
c,b,a

方法名：prefixLength
源码定义：

def prefixLength(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }

描述：给定一个条件 p，返回一个前置数列（数列开头的）满足条件的元素个数
返回值：
示例：

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

方法名：product
源码定义：

def product[B >: A](implicit num : scala.Numeric[B]) : B = { /* compiled code */ }

描述：返回所有元素乘积的值
返回值：
示例：

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

方法名：reduce
源码定义：

def reduce[A1 >: A](op : scala.Function2[A1, A1, A1]) : A1 = { /* compiled code */ }

描述：同 fold，不需要初始值，直接从序列中先拿出两个值
返回值：
示例：

scala> def seqno(m: Int, n: Int): Int = {
     |   val s = "seq_exp = %d + %d"
     |   println(s.format(m, n))
     |   m + n
     | }
seqno: (m: Int, n: Int)Int

scala>   val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala>   val b = a.reduce(seqno)
seq_exp = 1 + 2
seq_exp = 3 + 3
seq_exp = 6 + 4
b: Int = 10

方法名：reduceLeft
源码定义：

override def reduceLeft[B >: A](op : scala.Function2[B, A, B]) : B = { /* compiled code */ }

描述：同 fold、foldLeft、reduce，从左向右计算，不需要初始值
返回值：
示例：

scala> def seqno(m: Int, n: Int): Int = {
     | val s = "seq_exp = %d + %d"
     | println(s.format(m, n))
     | m + n
     | }
seqno: (m: Int, n: Int)Int

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.reduceLeft(seqno)
seq_exp = 1 + 2
seq_exp = 3 + 3
seq_exp = 6 + 4
b: Int = 10

scala> val a = Array[Int]()
a: Array[Int] = Array()

scala> val b = a.reduceLeft(seqno)
java.lang.UnsupportedOperationException: empty.reduceLeft
  at scala.collection.TraversableOnce$class.reduceLeft(TraversableOnce.scala:180)
  at scala.collection.mutable.ArrayOps$ofInt.scala$collection$IndexedSeqOptimized$$super$reduceLeft(ArrayOps.scala:234)
  at scala.collection.IndexedSeqOptimized$class.reduceLeft(IndexedSeqOptimized.scala:74)
  at scala.collection.mutable.ArrayOps$ofInt.reduceLeft(ArrayOps.scala:234)
  ... 32 elided

方法名：reduceLeftOption
源码定义：

def reduceLeftOption[B >: A](op : scala.Function2[B, A, B]) : scala.Option[B] = { /* compiled code */ }

描述：同 reduceLeft，计算Option
返回值： Option
示例：

scala> def seqno(m: Int, n: Int): Int = {
     |  val s = "seq_exp = %d + %d"
     |  println(s.format(m, n))
     |  m + n
     | }
seqno: (m: Int, n: Int)Int

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.reduceLeftOption(seqno)
seq_exp = 1 + 2
seq_exp = 3 + 3
seq_exp = 6 + 4
b: Option[Int] = Some(10)

scala> val a = Array[Int]()
a: Array[Int] = Array()

scala> val b = a.reduceLeftOption(seqno)
b: Option[Int] = None

方法名：reduceOption
源码定义：

def reduceOption[A1 >: A](op : scala.Function2[A1, A1, A1]) : scala.Option[A1] = { /* compiled code */ }

描述：同 reduceLeftOption，计算Option
返回值： Option
示例：

def seqno(m: Int, n: Int): Int = {
 val s = "seq_exp = %d + %d"
 println(s.format(m, n))
 m + n
}

def main(args: Array[String]) {
	val a = Array(1, 2, 3, 4)
	val b = a.reduceOption(seqno)
	println("b = " + b)	
} 
/*
 * seq_exp = 1 + 2
 * seq_exp = 3 + 3
 * seq_exp = 6 + 4
 * b = Some(10)
 */

方法名：reduceRight
源码定义：

override def reduceRight[B >: A](op : scala.Function2[A, B, B]) : B = { /* compiled code */ }

描述：同 foldRight，从右向左计算，不需要初始值
返回值：
示例：

def seqno(m: Int, n: Int): Int = {
	val s = "seq_exp = %d + %d"
	println(s.format(m, n))
	m + n
}

def main(args: Array[String]) {
	val a = Array(1, 2, 3, 4)
	val b = a.reduceRight(seqno)
	println("b = " + b)
}
/*
 * seq_exp = 3 + 4
 * seq_exp = 2 + 7
 * seq_exp = 1 + 9
 * b = 10
 */

方法名：reduceRightOption
源码定义：

def reduceRightOption[B >: A](op : scala.Function2[A, B, B]) : scala.Option[B] = { /* compiled code */ }

描述：同 reduceRight，计算Option
返回值： Option
示例：

def seqno(m: Int, n: Int): Int = {
	val s = "seq_exp = %d + %d"
	println(s.format(m, n))
	m + n
}

def main(args: Array[String]) {
	val a = Array(1, 2, 3, 4)
	val b = a.reduceRightOption(seqno)
	println("b = " + b)
}
/*
 * seq_exp = 3 + 4
 * seq_exp = 2 + 7
 * seq_exp = 1 + 9
 * b = 10
 */

方法名：repr
源码定义：

def repr : Repr = { /* compiled code */ }

描述： repr() 函数将对象转化为供解释器读取的形式
返回值：
示例：

val a = Map(1 -> "a",2 -> "b")
println(a.repr) //等于 println(a)  Map(1 -> a, 2 -> b)

val b = Array("java","scala")
println(b.repr) // 等于 println(b)  打印地址[Ljava.lang.String;@71423665

方法名：reverse
源码定义：

override def reverse : Repr = { /* compiled code */ }

描述：反转序列
返回值：
示例：

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

方法名：reverseIterator
源码定义：

 override def reverseIterator : scala.collection.Iterator[A] = { /* compiled code */ }

描述：生成反向迭代器
返回值：
示例：

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

方法名：reverseMap
源码定义：

def reverseMap[B, That](f : scala.Function1[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：同 map，方向相反
返回值：
示例：

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

方法名：runWith
源码定义：

def runWith[U](action : scala.Function1[B, U]) : scala.Function1[A, scala.Boolean] = { /* compiled code */ }

描述：执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action
返回值：
示例：

val pf: PartialFunction[Int, Int] = { case m: Int if m % 2 == 1=> m * 2 }
pf.runWith(println)(3)			// return: Boolean = true
pf.runWith(println)(2)			// return: Boolean = false

方法名：sameElements
源码定义：

override def sameElements[B >: A](that : scala.collection.GenIterable[B]) : scala.Boolean = { /* compiled code */ }

描述：判断两个序列是否顺序和对应位置上的元素都一样
返回值：
示例：

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

val d = Array(1, 2, 3, 4, 5)
println(a.sameElements(d)) // false

方法名：scan
源码定义：

def scan[B >: A, That](z : B)(op : scala.Function2[B, B, B])(implicit cbf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.scan(5)(_ + _)
b: Array[Int] = Array(5, 6, 8, 11, 15)

方法名：scanLeft
源码定义：

def scanLeft[B, That](z : B)(op : scala.Function2[B, A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：同 foldLeft，从左向右计算，每一步的计算结果放到一个新的集合中返回
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.scanLeft(5)(_ + _)
b: Array[Int] = Array(5, 6, 8, 11, 15)

方法名：scanRight
源码定义：

def scanRight[B, That](z : B)(op : scala.Function2[A, B, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.scanRight(5)(_ + _)
b: Array[Int] = Array(15, 14, 12, 9, 5)

方法名：segmentLength
源码定义：

override def segmentLength(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int = { /* compiled code */ }

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

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

方法名：seq
源码定义：

def seq : scala.collection.mutable.IndexedSeq[T] = { /* compiled code */ }

描述：产生一个引用当前序列的 sequential 视图
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.seq
b: scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4)

方法名：size
源码定义：

override def size : scala.Int = { /* compiled code */ }

描述：返回序列元素个数，同 length
返回值：
示例：

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

方法名：slice
源码定义：

override def slice(from : scala.Int, until : scala.Int) : Repr = { /* compiled code */ }

描述： 返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素(左闭右开)
返回值：
示例：

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

方法名：sliding
源码定义：

def sliding(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }
def sliding(size : scala.Int, step : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束。默认步长为1， (sliding(size, step) 可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始)
返回值：迭代器
示例：

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

方法名：sortBy
源码定义：

def sortBy[B](f : scala.Function1[A, B])(implicit ord : scala.math.Ordering[B]) : Repr = { /* compiled code */ }

描述：按指定的排序规则对序列排序
返回值：
示例：

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

val b = a.sortBy(x => x) // 按 x 从小到大，即对原序列升序排列
println("升序: " + b.mkString(",")) // 1,2,3,4

val c = a.sortBy(x => 0 - x) // 按 -x 从小到大，即对原序列降序排列
println("降序: " + c.mkString(",")) // 4,3,2,1

scala> val ff = Array(("zs",50),("ls",80),("ww",70))
ff: Array[(String, Int)] = Array((zs,50), (ls,80), (ww,70))

scala> ff.sortBy(x=>x._2)
res148: Array[(String, Int)] = Array((zs,50), (ww,70), (ls,80))

方法名：sortWith
源码定义：

在这里插入代码片

描述：自定义排序方法
返回值：
示例：

scala> val g = Array(3,2,1,1,2,3,1,2,3)
g: Array[Int] = Array(3, 2, 1, 1, 2, 3, 1, 2, 3)

scala> g.sortWith(_.compareTo(_)>0)
res146: Array[Int] = Array(3, 3, 3, 2, 2, 2, 1, 1, 1)

scala> g.sortWith(_.compareTo(_)<0)
res147: Array[Int] = Array(1, 1, 1, 2, 2, 2, 3, 3, 3)

方法名：sorted
源码定义：

def sorted[B >: A](implicit ord : scala.math.Ordering[B]) : Repr = { /* compiled code */ }

描述：默认升序排列，无参数
返回值：序列
示例：

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

方法名：span
源码定义：

override def span(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

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

scala> g
res150: Array[Int] = Array(3, 2, 1, 1, 2, 3, 1, 2, 3)

scala> g.partition(_%2==0)
res151: (Array[Int], Array[Int]) = (Array(2, 2, 2),Array(3, 1, 1, 3, 1, 3))

scala> g.span(_%2==0)
res152: (Array[Int], Array[Int]) = (Array(),Array(3, 2, 1, 1, 2, 3, 1, 2, 3))

方法名：splitAt
源码定义：

override def splitAt(n : scala.Int) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }

描述：从指定位置开始，把序列拆分成两个数组，指定索引位置元素放入第二个数组中
示例：

val a = Array(5,6,7,8,9)
val b = a.splitAt(2)
println(b._1.mkString(",")) //  5,6
println(b._2.mkString(",")) //  7,8,9

方法名：startsWith
源码定义：

def startsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }
def startsWith[B](that : scala.collection.GenSeq[B], offset : scala.Int) : scala.Boolean

描述：判断序列是否以某个序列开始。 startsWith(that, offset) ：判断序列从指定偏移处是否以某个序列开始)
返回值：
示例：

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

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

方法名：stringPrefix
源码定义：

def stringPrefix : scala.Predef.String = { /* compiled code */ }

描述：返回 toString 结果的前缀
返回值：
示例：

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

方法名：sum
源码定义：

def sum[B >: A](implicit num : scala.Numeric[B]) : B = { /* compiled code */ }

描述：序列求和，元素需为 Numeric[T] 类型
返回值：
示例：

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

scala> val a = Array('a',1,2,3)
a: Array[Int] = Array(97, 1, 2, 3)

scala> a.sum
res157: Int = 103

scala> 'q'+:a
res158: Array[AnyVal] = Array(q, 97, 1, 2, 3)

scala> res158.sum
<console>:14: error: could not find implicit value for parameter num: Numeric[AnyVal]
       res158.sum

方法名：tail
源码定义：

override def tail : Repr = { /* compiled code */ }

描述：返回当前序列中不包含第一个元素的序列
返回值：
示例：

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

方法名：tails
源码定义：

def tails : scala.collection.Iterator[Repr] = { /* compiled code */ }

描述：同 inits，每一步都进行 tail 操作
返回值：
示例：

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

方法名：take
源码定义：

override def take(n : scala.Int) : Repr = { /* compiled code */ }

描述：返回当前序列中，前 n 个元素组成的序列
返回值：
示例：

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

方法名：takeRight
源码定义：

override def takeRight(n : scala.Int) : Repr = { /* compiled code */ }

描述：返回当前序列中，从右边开始，后 n 个元素组成的序列
返回值：
示例：

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

方法名：takeWhile
源码定义：

override def takeWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }

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

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

方法名：to
源码定义：

描述：
返回值：
示例：

方法名：toArray
源码定义：

描述：将序列转换成 Array 类型
返回值：
示例：
方法名：toBuffer
源码定义：

描述：将序列转换成 Buffer 类型
返回值：
示例：

方法名：toIndexedSeq
源码定义：

描述：将序列转换成 IndexedSeq 类型
返回值：
示例：

方法名：toIterable
源码定义：

描述：将序列转换成 Iterable 类型
返回值：
示例：

方法名：toIterator
源码定义：

描述：将序列转换成迭代器，同 iterator 方法
返回值：
示例：

方法名：toList
源码定义：

描述：将序列转换成 List 类型
返回值：
示例：

方法名：toMap
源码定义：

描述：将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型
返回值：
示例：

方法名：toSeq
源码定义：

描述：将序列转换成 Seq 类型
返回值：
示例：

方法名：toSet
源码定义：

描述：将序列转换成 Set 类型
返回值：
示例：

方法名：toStream
源码定义：

描述：将序列转换成 Stream 类型
返回值：
示例：

方法名：toTraversable
源码定义：

描述：将序列转换成 Traversable 类型
返回值：
示例：

方法名：toVector
源码定义：

描述：将序列转换成 Vector 类型
返回值：
示例：

方法名：transform
源码定义：

描述：
返回值：
示例：

方法名：transpose
源码定义：

def transpose[U](implicit asArray : scala.Function1[T, scala.Array[U]]) : scala.Array[scala.Array[U]] = { /* compiled code */ }

描述：矩阵转置，二维数组行列转换，二维数组的长度可以不一致，结果为缺省，但必须是二维数组
返回值：
示例：

scala> val a = Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
a: Array[Array[String]] = Array(Array(a, b), Array(c, d), Array(e, f))

scala> val b = a.transpose
b: Array[Array[String]] = Array(Array(a, c, e), Array(b, d, f))

scala> b.foreach(x => println((x.mkString(","))))
a,c,e
b,d,f

scala> val a = Array(Array(1,2),Array(3))
a: Array[Array[Int]] = Array(Array(1, 2), Array(3))

scala> a.transpose
res85: Array[Array[Int]] = Array(Array(1, 3), Array(2))

scala> val a = Array(Array(1,2),Array(3),1)
a: Array[Any] = Array(Array(1, 2), Array(3), 1)

scala> a.transpose
<console>:17: error: No implicit view available from Any => Array[U].
       a.transpose

scala> val a = Array(Array(1,2,7),Array(3,4,8),Array(5,6,9))
a: Array[Array[Int]] = Array(Array(1, 2, 7), Array(3, 4, 8), Array(5, 6, 9))

scala> a.transpose
res88: Array[Array[Int]] = Array(Array(1, 3, 5), Array(2, 4, 6), Array(7, 8, 9))

scala> a.transpose.transpose
res89: Array[Array[Int]] = Array(Array(1, 2, 7), Array(3, 4, 8), Array(5, 6, 9))

方法名：union
源码定义：

override def union[B >: A, That](that : scala.collection.GenSeq[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：合并两个序列，同操作符 ++，相当于数据库中的union all(不会去重)
返回值：
示例：

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

scala> b
res92: Array[Int] = Array(3, 4, 1, 1, 3)

scala> val c = Array(1,1,1,2,3,4,5)
c: Array[Int] = Array(1, 1, 1, 2, 3, 4, 5)

scala> b ++c
res93: Array[Int] = Array(3, 4, 1, 1, 3, 1, 1, 1, 2, 3, 4, 5)

scala> res93.distinct
res94: Array[Int] = Array(3, 4, 1, 2, 5)

方法名：unzip
源码定义：

def unzip[T1, T2](implicit asPair : scala.Function1[T, scala.Tuple2[T1, T2]], ct1 : scala.reflect.ClassTag[T1], ct2 : scala.reflect.ClassTag[T2]) : scala.Tuple2[scala.Array[T1], scala.Array[T2]] = { /* compiled code */ }

描述：将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组。元组的数量可以为多个，但元组里的元素数量必须是2个。
返回值：
示例：

scala> val a = Array(("a", "b"), ("c", "d"))
a: Array[(String, String)] = Array((a,b), (c,d))

scala> val b = a.unzip
b: (Array[String], Array[String]) = (Array(a, c),Array(b, d))

方法名：unzip3
源码定义：

def unzip3[T1, T2, T3](implicit asTriple : scala.Function1[T, scala.Tuple3[T1, T2, T3]], ct1 : scala.reflect.ClassTag[T1], ct2 : scala.reflect.ClassTag[T2], ct3 : scala.reflect.ClassTag[T3]) : scala.Tuple3[scala.Array[T1], scala.Array[T2], scala.Array[T3]] = { /* compiled code */ }

描述：将含有3个元祖的数组，每个元祖的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组。元组的数量可以为多个，但元组里的元素数量必须是3个。
返回值：
示例：

scala> val a = Array(("a", "b", "x"), ("c", "d", "y"), ("e", "f", "z"))
a: Array[(String, String, String)] = Array((a,b,x), (c,d,y), (e,f,z))

scala> val b = a.unzip3
b: (Array[String], Array[String], Array[String]) = (Array(a, c, e),Array(b, d, f),Array(x, y, z))

方法名：update
源码定义：

def update(i : scala.Int, x : T) : scala.Unit = { /* compiled code */ }

描述：将序列中 i 索引处的元素更新为 x (直接在本数组上修改)
返回值：
示例：

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

方法名：updated
源码定义：

def updated[B >: A, That](index : scala.Int, elem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }

描述：将序列中 i 索引处的元素更新为 x，并返回替换后的数组（修改副本）
返回值：
示例：

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

方法名：view
源码定义：

override def view : scala.AnyRef with scala.collection.mutable.IndexedSeqView[A, Repr] = { /* compiled code */ }
override def view(from : scala.Int, until : scala.Int) : scala.collection.mutable.IndexedSeqView[A, Repr] = { /* compiled code */ }

描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素(左闭右开)
返回值：
示例：

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

scala> a
res111: Array[(Int, Int)] = Array((1,4), (3,4), (32,45))

scala> a.view(1,3)
res112: scala.collection.mutable.IndexedSeqView[(Int, Int),Array[(Int, Int)]] = SeqViewS(...)

方法名：withFilter
源码定义：

def withFilter(p : scala.Function1[A, scala.Boolean]) : scala.collection.generic.FilterMonadic[A, Repr] = { /* compiled code */ }

描述：根据条件 p 过滤元素
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = a.withFilter(x => x > 2).map(x => x)
b: Array[Int] = Array(3, 4)

scala> b.filter(_>2)
res121: Array[Int] = Array(3, 4, 3)

scala> b.withFilter(_>2)
res122: scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@1f4f5eb

方法名：zip
源码定义：

override def zip[A1 >: A, B, That](that : scala.collection.GenIterable[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, B], That]) : That = { /* compiled code */ }

描述：将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度最好保证相同，不同的话取最小长度的序列长度，进行组成一个元组数组，其他的值过滤掉。
返回值：
示例：

scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b = Array(4, 3, 2, 1)
b: Array[Int] = Array(4, 3, 2, 1)

scala> val c = a.zip(b)
c: Array[(Int, Int)] = Array((1,4), (2,3), (3,2), (4,1))

scala> b
res123: Array[Int] = Array(3, 4, 1, 1, 3)

scala> c
res124: Array[Int] = Array(1, 1, 1, 2, 3, 4, 5)

scala> b.zip(c)
res125: Array[(Int, Int)] = Array((3,1), (4,1), (1,1), (1,2), (3,3))

scala> c.zip(b)
res126: Array[(Int, Int)] = Array((1,3), (1,4), (1,1), (2,1), (3,3))

方法名：zipAll
源码定义：

def zipAll[B, A1 >: A, That](that : scala.collection.GenIterable[B], thisElem : A1, thatElem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, B], That]) : That = { /* compiled code */ }

描述：同 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 x = Array(1, 2, 3, 4)
val y = Array(6, 5, 4, 3, 2, 1)
val z = x.zipAll(y, 8, 9) // (1,6),(2,5),(3,4),(4,3),(8,2),(8,1)
println(z.mkString(","))

方法名：zipWithIndex
源码定义：

override def zipWithIndex[A1 >: A, That](implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, scala.Int], That]) : That = { /* compiled code */ }

描述：序列中的每个元素和它的索引组成一个元组数组
返回值：
示例：

val a = Array('a', 'b', 'c', 'd')
val b = a.zipWithIndex
println(b.mkString(",")) // (a,0),(b,1),(c,2),(d,3)

方法名： subSequence
源码定义：

def subSequence(start : scala.Int, end : scala.Int) : java.lang.CharSequence = { /* compiled code */ }

描述：返回 start 和 end 间的字符序列，不包含 end 处的元素
返回值：
示例：

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

以上就是本人对常用经典的十大排序算法的理解，有不足之处，望指点！万分感谢！

在这里插入图片描述

BigData_Hubert

关注

6
点赞
踩
31

收藏

觉得还不错? 一键收藏
2
评论
scala 数组函数大全（143个1个不漏，全面案例详解）

scala系列scala 143个数组函数大全scala 数组函数大全scala系列前言一、scala 数据简介二、数组函数汇总前言本篇博客为大家带来的是 scala 所有（没错，没有看错，就是所有）数组函数的案例详解大全。scala 数组函数是 scala 能够实现代码飘逸的核心基础所在，因此在 scala 入门的时候必须强记下来，没有任何商量的余地。相信大家在看完的数组函数汇总后，都能够代码敲的飘逸！“so easy”![在这里插入图片描述](https://img-blog.
复制链接

扫一扫