目录
1. 添加类函数
2.生成类函数
3.删除类函数
4.查找类函数
5.统计类函数
6.修改类函数
7.判断类函数
8.获取集合元素
9.集合操作类函数
10.转换类函数
11.工具类函数
12.集合内与集合间计算函数
在 scala 中Array数组是一种可变的、可索引的数据集合
创建数组语法为
val arr : Array[Int] = Array(1,2,3)
[ ]内为数组内的数据类型（Any 表示任何类型，如果你研究过 scala 就会明白 scala 有面向对象的特点，这里 Any 就是对象的父类，类比 java 中的 object）
Array 数组的 基础操作：
val arr = Array(1, 2, 3, 4) // 声明一个数组对象
val first = arr(0) // 读取第一个元素
arr(3) = 100 // 替换第四个元素为 100
val newarr = arr.map(_ * 2) // 所有元素乘 2
println(newarr.mkString(",")) // 打印数组，结果为：2,4,6,200
Array 数组的函数：
1. 添加类函数
++
定义
def ++[B >: A, That](that : scala.collection.GenTraversableOnce[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }
描述：合并集合，并返回一个新的数组，新数组包含左右两个集合的内容
演示：
val a = Array(1,2,3)val b = Array(3,4,5)val ints1: Array[Int] = a ++ bprintln(ints1.toList)
++:
定义：
def ++:[B >: A, That](that : scala.collection.Traversable[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }
描述：这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型
示例：Array 和 List 结合，返回结果是 List 类型
val a = Array(1,2,3)val b = List(3,4,5)val ints1 = a ++: bprintln(ints1.getClass.getName)
+:
定义：
def +:[B >: T](elem : B)(implicit evidence$3 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }
描述：在数组前面添加一个元素，并返回新的数组对象
示例：
val a = Array(1,2,3,4)val ints: Array[Int] = 0 +: aprintln(ints.toList)
:+
定义：
def :+[B >: T](elem : B)(implicit evidence$2 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }
描述：在数组后面添加一个元素，并返回新的数组对象
示例：
val a = Array(1,2,3,4)val ints: Array[Int] = a :+ 0println(ints.toList)
2.生成类函数
定义：
override def clone() : scala.Array[T] = { /* compiled code */ }描述：克隆，创建一个副本
示例：clone 和 = 的区别通过下面的结果很容易就能对比出来
var a = Array(1,2,3)var b = avar c = a.clonea(0) = 0println(b.toList)println(c.toList)
collect
定义：
def collect[B, That](pf : scala.PartialFunction[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }
描述：通过执行一个并行计算（偏函数），得到一个新的数组对象
示例：通过下面的偏函数（参数只能是偏函数），把数组中的1转换为“a”
val a = Array(1,2,3)def fun : PartialFunction[Int,String]={case 1 => "a"case _ => "other"}println(a.collect(fun).toList )collectFirst
定义：
def collectFirst[B](pf : scala.PartialFunction[A, B]) : scala.Option[B] = { /* compiled code */ }描述：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算，返回一个 option
示例：
val a = Array(1,2,3)def fun : PartialFunction[Int,String]={case 1 => "a"case _ => "other"}println(a.collectFirst(fun) )
偏函数也可以用匿名函数表示
val a = Array(1,2,3)println(a.collectFirst({case x : Int if (x ==2) => x+1}) )
combinations
定义：
def combinations(n : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }描述：combinations 表示组合，这个排列组合会选出所有包含元素不一样的组合，但不考虑顺序，对于 “123”、“321”，视为相同组合，参数 n 表示序列长度，就是几个元素为一组，返回的是一个迭代器，迭代器里存放的是 每一种组合的Array 数组
val a = Array(1,2,3)val combine: Iterator[Array[Int]] = a.combinations(2)combine.foreach(x=>println(x.toList))
permutations
定义：
def permutations : scala.collection.Iterator[Repr] = { /* compiled code */ }
描述：permutations 表示排列，这个排列组合会选出所有排列顺序不同的元素组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合
示例：
val a = Array(1,2,3)val permutations: Iterator[Array[Int]] = a.permutationspermutations.foreach(x=>println(x.toList))
copyToArray(xs)
定义：
def copyToArray[B >: A](xs : scala.Array[B]) : scala.Unit = { /* compiled code */ }
描述：将当前数组元素复制到另一个数组中
示例：
val a = Array(1,2,3)val b = new Array[Int](5)a.copyToArray(b)println(b.toList)
copyToArray(arr, start)
定义：
def copyToArray[B >: A](xs : scala.Array[B], start : scala.Int) : scala.Unit = { /* compiled code */ }
描述：将当前数组元素复制到另一个数组中，从 start 位置开始复制
示例：
val a = Array(1,2,3)val b = new Array[Int](5)a.copyToArray(b,1)println(b.toList)
copyToArray(arr, start, len)
定义：
override def copyToArray[U >: T](xs : scala.Array[U], start : scala.Int, len : scala.Int) : scala.Unit = { /* compiled code */ }
描述：将当前数组元素复制到另一个数组中，从 start 位置开始复制，长度为 len
示例：
val a = Array(1,2,3)val b = new Array[Int](5)a.copyToArray(b,1,2)println(b.toList)
copyToBuffer
定义：
def copyToBuffer[B >: A](dest : scala.collection.mutable.Buffer[B]) : scala.Unit = { /* compiled code */ }描述：将数组中的元素复制到 Buffer 中
示例：
val a = Array(1,2,3)val buffer: ArrayBuffer[Int] = ArrayBuffer()a.copyToBuffer(buffer)println(buffer.toList)
3.删除类函数
定义：
override def drop(n : scala.Int) : Repr = { /* compiled code */ }描述：将当前数组中前 n 个元素去除，返回一个新数组
示例：
val a = Array(1,2,3,4,5,6,7)val ints: Array[Int] = a.drop(3)println(ints.toList)
dropRight
定义：
override def dropRight(n : scala.Int) : Repr = { /* compiled code */ }描述：功能同 drop，去掉尾部的 n 个元素
示例：
val a = Array(1,2,3,4,5,6,7)val ints: Array[Int] = a.dropRight(3)println(ints.toList)
dropWhile
定义：
override def dropWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }
描述：去除当前数组中符合条件的元素，返回剩余的数组，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组
示例：
val a = Array(1,2,3,4,5,6,7,1)val ints: Array[Int] = a.dropWhile(x=>x<3)println(ints.toList)
4.查找类函数
定义：
override def find(p : scala.Function1[A, scala.Boolean]) : scala.Option[A] = { /* compiled code */ }
描述：查找第一个符合条件的元素，返回 Option
示例：
val a = Array(1,2,3,4,5,6,2,1)val maybeInt: Option[Int] = a.find(x => x==2)println(maybeInt)
last
定义：
override def last : A = { /* compiled code */ }描述：返回序列的最后一个元素，如果序列为空，将引发错误
示例：
val a = Array(1,2,3,4,5,6)val last: Int = a.lastprintln(last)
lastIndexOf(elem)
定义：
def lastIndexOf[B >: A](elem : B) : scala.Int = { /* compiled code */ }
描述：返回元素 elem 在序列中最后一次出现的索引
示例：
val a = Array(1,2,3,4,5,6)val index: Int = a.lastIndexOf(5)println(index)lastIndexOf(elem, end)
定义：
def lastIndexOf[B >: A](elem : B, end : scala.Int) : scala.Int = { /* compiled code */ }
描述：返回元素 elem 在序列中最后一次出现的索引，指定在索引 end 之前（包括）的元素中查找
示例：
val a = Array(1,2,3,4,5,6,2,1)val index: Int = a.lastIndexOf(2,5)println(index)
lastIndexOfSlice(that)
定义：
def lastIndexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }
描述：检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引
示例：
val a = Array(1,2,3,4,5,6,3,4,2,1)val slice = Array(3,4)val index: Int = a.lastIndexOfSlice(slice)println(index)
lastIndexOfSlice(that, end)
定义：
def lastIndexOfSlice[B >: A](that : scala.collection.GenSeq[B], end : scala.Int) : scala.Int = { /* compiled code */ }
描述：检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引，指定在索引 end 之前（包括）的元素中查找
示例：
val a = Array(1,2,3,4,5,6,3,4,2,1)val slice = Array(3,4)val index: Int = a.lastIndexOfSlice(slice,5)println(index)
lastIndexWhere
定义：
def lastIndexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }
描述：返回当前序列中最后一个满足条件 p 的元素的索引
示例：
val a = Array(1,2,3,4,5,6,3,4,2,1)val index: Int = a.lastIndexWhere(x=>x>3)println(index)
lastIndexWhere(p, end)
定义：
def lastIndexWhere(p : scala.Function1[A, scala.Boolean], end : scala.Int) : scala.Int
描述：返回当前序列中最后一个满足条件 p 的元素的索引，指定在索引 end 之前（包括）的元素中查找
示例：
val a = Array(1,2,3,4,5,6,3,4,2,1)val index: Int = a.lastIndexWhere(x=>x>3,5)println(index)
lastOption
定义：
def lastOption : scala.Option[A] = { /* compiled code */ }描述：返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
示例：
val a = Array(1,2,3,4,5,6,3,4,2,1)val option: Option[Int] = a.lastOptionprintln(option) 
indexOf(elem)
定义：
def indexOf[B >: A](elem : B) : scala.Int = { /* compiled code */ }
描述：返回元素 elem 在序列中第一次出现的索引
示例：
val a = Array(1,2,3,4,5,6,3,4,2,1)val i: Int = a.indexOf(2)println(i) 
indexOf(elem, from)
定义：
def indexOf[B >: A](elem : B, from : scala.Int) : scala.Int = { /* compiled code */ }
描述：返回元素 elem 在序列中第一次出现的索引，指定从索引 from 开始查找
示例：
val a = Array(1,2,3,4,5,6,3,4,2,1)val i: Int = a.indexOf(2,3)println(i)
indexOfSlice(that)
定义：
def indexOfSlice[B >: A](that : scala.collection.GenSeq[B]) : scala.Int = { /* compiled code */ }
描述：检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引
示例：
val a = Array(1,2,1,3,4,5,6,3,4,2,1)val slide = Array(2,1)val i: Int = a.indexOfSlice(slide)println(i)
indexOfSlice(that, from)
定义：
def indexOfSlice[B >: A](that : scala.collection.GenSeq[B], from : scala.Int) : scala.Int = { /* compiled code */ }
描述：检测当前序列中是否包含另一个序列 that，指定从索引 from 开始查找，并返回第一次出现该序列的索引
示例：
val a = Array(1,2,1,3,4,5,6,3,4,2,1)val slide = Array(2,1)val i: Int = a.indexOfSlice(slide,4)println(i)
indexWhere
定义：
def indexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }
描述：返回当前序列中第一个满足条件 p 的元素的索引
示例：
val a = Array(1,2,1,3,4,5,6,3,4,2,1)val i: Int = a.indexWhere(x=>x>3)println(i)
indexWhere(p, from)
定义：
def indexWhere(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int
描述：返回当前序列中第一个满足条件 p 的元素的索引，指定从索引 from 开始查找
示例：
val a = Array(1,2,1,3,4,5,6,3,4,2,1)val i: Int = a.indexWhere(x=>x>3,6)println(i)
segmentLength
定义：
override def segmentLength(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int = { /* compiled code */ }
描述：从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个
示例：
val a = Array(1,2,1,3,4,5,6,3,4,2,1)println(a.segmentLength(x=>x>3,0))println(a.segmentLength(x=>x>3,4))
5.统计类函数
count
定义：
def count(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }
描述：统计符合条件的元素个数
示例：下面代码统计数组中所以元素个数和大于 2 的元素个数
val a = Array(1,2,3,4)println(a.count(x=>true))println(a.count(x=>x>2))
max
定义：
def max[B >: A](implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }描述：返回序列中最大的元素
示例：
val a = Array(1, 2, 3, 4)
println(a.max) // 4
maxBy
定义：
def maxBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A = { /* compiled code */ }
描述：返回序列中符合条件的第一个元素
示例：
val a = Array(1, 2, 3, 4)
println(a.maxBy(x => x > 2)) // 3min
定义：
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 */ }
描述：返回序列中不符合条件的第一个元素
示例：
val a = Array(1, 2, 3, 4)
println(a.minBy(x => x < 2)) // 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
sum
定义：
def sum[B >: A](implicit num : scala.Numeric[B]) : B = { /* compiled code */ }
描述：序列求和，元素需为 Numeric[T] 类型
示例：
val a = Array(1, 2, 3, 4)
println(a.sum) // 106.修改类函数
update
定义：
def update(i : scala.Int, x : T) : scala.Unit = { /* compiled code */ }
描述：将序列中 i 索引处的元素更新为 x
示例：
val a = Array(1,2,3,4)a.update(1,0)println(a.toList)
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 ints: Array[Int] = a.updated(1, 0)println(ints.toList)
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(9,8,7)val ints: Array[Int] = a.patch(1, b, 2)println(ints.toList)
7.判断类函数
contains
定义：
def contains[A1 >: A](elem : A1) : scala.Boolean = { /* compiled code */ }
描述：判断序列中是否包含指定对象
示例：
val a = Array(1,2,3,4)println(a.contains(4))
containsSlice
定义：
def containsSlice[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }
描述：判断当前序列中是否包含另一个序列
示例：
val a = Array(1,2,3,4)println(a.containsSlice(List(2,1)))println(a.containsSlice(List(1,2)))
endsWith
定义：
override def endsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }
描述：判断当前序列是否以某个序列结尾
示例：
val a = Array(1,2,3,4)println(a.endsWith(List(3,4)))
exists
定义：
override def exists(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }
描述：判断当前数组是否包含符合条件的元素
示例：
val a = Array(1,2,3,4)println(a.exists(x=>x>5))println(a.exists(x=>x==3))
isDefinedAt
定义：
def isDefinedAt(idx : scala.Int) : scala.Boolean = { /* compiled code */ }
描述：判断序列中是否存在指定索引
示例：
val a = Array(1,2,3,4)println(a.isDefinedAt(3))
isEmpty
定义：
override def isEmpty : scala.Boolean = { /* compiled code */ }
描述：判断序列是否为空
示例：
val a = Array(1,2,3,4)val b = new Array[Any](0)println(a.isEmpty)println(b.isEmpty)
isTraversableAgain
定义：
final def isTraversableAgain : scala.Boolean = { /* compiled code */ }
描述：判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写
示例：
val a = Array(1,2,3,4)val b = a.iteratorprintln(a.isTraversableAgain)println(b.isTraversableAgain)
forall
定义：
override def forall(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }
描述：检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true
示例：
val a = Array(1,2,3,4)println(a.forall(x=>x>2))println(a.forall(x=>x>0))
nonEmpty
定义：
def nonEmpty : scala.Boolean = { /* compiled code */ }
描述：判断序列是否不为空
示例：
val a = Array(1,2,3,4)val b = new Array[Any](0)println(a.nonEmpty)println(b.nonEmpty)
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)val c = Array(1,4,3,2)println("a 和 b："+a.sameElements(b))println("a 和 c："+a.sameElements(c))
startsWith(that)
定义：
def startsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }
描述：判断序列是否以某个序列开始
示例：
val a = Array(1,2,3,4)println("a开头是否有 1，2："+a.startsWith(Array(1,2)))
startsWith(that, offset)
定义：
def startsWith[B](that : scala.collection.GenSeq[B], offset : scala.Int) : scala.Boolean
描述：判断序列从指定偏移处是否以某个序列开始
示例：
val a = Array(1,2,3,4)println("a在 1 位置是否有 2，3："+a.startsWith(Array(2,3),1))
hasDefiniteSize
定义：
override def hasDefiniteSize : scala.Boolean = { /* compiled code */ }
描述：检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false
示例：
val a = Array(1,2,3,4)val b = 1 #:: 2 #:: 3 #:: Stream.emptyprintln("array数组是否存在有限的长度"+a.hasDefiniteSize)println("stream流是否存在有限的长度"+b.hasDefiniteSize)
canEqual
定义：
override def canEqual(that : scala.Any) : scala.Boolean = { /* compiled code */ }
描述：判断两个对象是否可以进行比较
示例：基本上所有对象都可以进行比较，我不知道这个方法的意义何在
val a = List(1, 2, 3, 4)
val b = Array('a', 'b', 'c')
println(a.canEqual(b)) // true
val chars = Array('a', 'b', 'c')
println(chars.charAt(0)) // a
corresponds
定义：
def corresponds[B](that : scala.collection.GenSeq[B])(p : scala.Function2[A, B, scala.Boolean]) : scala.Boolean = { /* compiled code */ }
描述：判断两个序列的长度是否相等再判断对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 f(x, y)=true，则返回 true
示例：下面代码检查 a 和 b 长度是否相等，并且 a 中元素是否小于 b 中对应位置的元素
val a = Array(1, 2, 3, 4)val b = Array(5, 6, 7, 8)println(a.corresponds(b)(_ < _))
8.获取集合元素
apply
定义：
def apply(i : scala.Int) : T = { /* compiled code */ }
描述：获取指定索引处的元素,与a(0)的取值方法很像，但是当数组中有不同类型的时候，用 apply 取值则会报错
示例：
//val a: Array[Any] = Array(1,2, "a", "b")val a: Array[Any] = Array( "a", "b")println(a.apply(0))println(a(1))
charAt
定义：
def charAt(index : scala.Int) : scala.Char = { /* compiled code */ }
描述：获取 index 索引处的字符，这个方法会执行一个隐式的转换，将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生
示例：
val a = Array('a','b','c')println(a.charAt(2))
foreach
定义：
override def foreach[U](f : scala.Function1[A, U]) : scala.Unit = { /* compiled code */ }
描述：遍历序列中的元素，进行 f 操作
示例：
val a = Array('a','b','c')a.foreach(println)
head
定义：
override def head : A = { /* compiled code */ }
描述：返回序列的第一个元素，如果序列为空，将引发错误
示例：
val a = Array('a','b','c')println(a.head)
headOption
定义：
def headOption : scala.Option[A] = { /* compiled code */ }
描述：返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
示例：
val a = Array('a','b','c')println(a.headOption)
init
定义：
override def init : Repr = { /* compiled code */ }
描述：返回当前序列中不包含最后一个元素的序列
示例：
val a = Array('a','b','c')println(a.init.toList)
inits
定义：
def inits : scala.collection.Iterator[Repr] = { /* compiled code */ }
描述：对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象
示例：
val a = Array('a','b','c','d')val inits: Iterator[Array[Char]] = a.initsinits.foreach(x=>println(x.toList))
tail
定义：
override def tail : Repr = { /* compiled code */ }
描述：同 init，返回当前序列中不包含第一个元素的序列
示例：
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('a','b','c','d')val inits: Iterator[Array[Char]] = a.tailsinits.foreach(x=>println(x.toList))
take
定义：
override def take(n : scala.Int) : Repr = { /* compiled code */ }
描述：返回当前序列中，前 n 个元素组成的序列
示例：
val a = Array('a','b','c','d')val b: Array[Char] = a.take(2)println(b.toList)
takeRight
定义：
override def takeRight(n : scala.Int) : Repr = { /* compiled code */ }
描述：返回当前序列中，从右边开始，后 n 个元素组成的序列
示例：
val a = Array('a','b','c','d')val b: Array[Char] = a.takeRight(2)println(b.toList)
takeWhile
定义：
override def takeWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }
描述：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
示例：
val a = Array('a','b','c','d')val b: Array[Char] = a.takeWhile(x=>x<'c')println(b.toList)println(a.takeWhile(x=>x=='b').toList)
view
定义：
override def view(from : scala.Int, until : scala.Int) : scala.collection.mutable.IndexedSeqView[A, Repr] = { /* compiled code */ }
描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素
示例：
val a = Array('a','b','c','d')val value: mutable.IndexedSeqView[Char, Array[Char]] = a.view(1, 3)println(value.toList)
9.集合操作类函数
filter
定义：
def filter(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }
描述：取得当前数组中符合条件的元素，组成新的数组返回
示例：
val a = Array(1,2,3,4)val ints: Array[Int] = a.filter(_ > 2)println(ints.toList)
filterNot
定义：
def filterNot(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }
描述：取得当前数组中不符合条件的元素，组成新的数组返回
示例：
val a = Array(1,2,3,4)val ints: Array[Int] = a.filterNot(_ > 2)println(ints.toList)
withFilter
定义：
def withFilter(p : scala.Function1[A, scala.Boolean]) : scala.collection.generic.FilterMonadic[A, Repr] = { /* compiled code */ }
描述：根据条件 p 过滤元素，如果后续的操作需要使用到map/flatMap/withFilter，推荐使用，这样可以减少filter产生的中间collection，使得执行更加高效
示例：
val a = Array(1,2,3,4)val ints: Array[Int] = a.withFilter(_ > 2).map(x => x+1)println(ints.toList)
reverse
定义：
override def reverse : Repr = { /* compiled code */ }
描述：反转序列，返回一个 Array 数组
示例：
val a = Array(1,2,3,4)val reverse: Array[Int] = a.reverseprintln(reverse.toList)
reverseIterator
定义：
override def reverseIterator : scala.collection.Iterator[A] = { /* compiled code */ }
描述：生成反向迭代器
示例：
val a = Array(1,2,3,4)val iterator: Iterator[Int] = a.reverseIteratorprintln(iterator.toList)
par
定义：
override def par : scala.collection.parallel.mutable.ParArray[T] = { /* compiled code */ }
描述：返回一个并行实现，产生的并行序列不能被修改
示例：
val a = Array(1,2,3,4,21)val par: ParArray[Int] = a.parprintln(par)
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(",")) println("奇数: " + b._2.mkString(",")) 
groupBy
定义：
def groupBy[K](f : scala.Function1[A, K]) : scala.collection.immutable.Map[K, Repr] = { /* compiled code */ }
描述：按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
示例：把数组中元素分为小于 2、大于 2 和其他，返回 Map[String, Array[Int]]
val a = Array(1,2,3,4)val stringToInts: Map[String, Array[Int]] = a.groupBy(x => x match {case x if (x > 2) => "big"case x if (x < 2) => "small"case _ => "none"})stringToInts.foreach(x=>println(x._1+" : "+x._2.toList))
grouped
定义：
def grouped(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }
描述：按指定数量分组，每组有 size 个元素，返回一个迭代器
示例：
val a = Array(1,2,3,4)val b: Iterator[Array[Int]] = a.grouped(2)b.foreach(x=>println(x.toList))
sortBy
定义：
def sortBy[B](f : scala.Function1[A, B])(implicit ord : scala.math.Ordering[B]) : Repr = { /* compiled code */ }
描述：按指定的排序规则对序列排序
示例：
val a = Array(1,3,2,4)val ints: Array[Int] = a.sortBy(x => x)println("升序排列："+ints.toList)println("倒序排列："+a.sortBy(x => 0 - x).toList)
sorted
定义：
def sorted[B >: A](implicit ord : scala.math.Ordering[B]) : Repr = { /* compiled code */ }
描述：使用默认的排序规则对序列排序
示例：
val a = Array(1,2,4,3)val sorted: Array[Int] = a.sortedprintln(sorted.toList)
slice
定义：
override def slice(from : scala.Int, until : scala.Int) : scala.Array[T] = { /* compiled code */ }
描述：返回当前序列中索引从 from 到 until 之间的序列，不包括 until 处的元素
示例：
val a = Array(1,2,3,4,5)val ints: Array[Int] = a.slice(2, 4)println(ints.toList)
sliding(size)
定义：
def sliding(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }
描述：滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束
示例：
val a = Array(1,2,3,4,5)val iterator: Iterator[Array[Int]] = a.sliding(3)iterator.foreach(x=>println(x.toList))
sliding(size, step)
定义：
def sliding(size : scala.Int, step : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }
描述：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束。该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始
示例：
val a = Array(1,2,3,4,5)val iterator: Iterator[Array[Int]] = a.sliding(3,2)iterator.foreach(x=>println(x.toList)) 
span
定义：
override def span(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }
描述：将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
示例：
val a = Array(1,2,3,4,5,4,3,2,1)val tuple: (Array[Int], Array[Int]) = a.span(x => x < 3)println(tuple._1.toList)println(tuple._2.toList)
splitAt
定义：
override def splitAt(n : scala.Int) : scala.Tuple2[Repr, Repr] = { /* compiled code */ }
描述：从指定位置开始，把序列拆分成两个数组
示例：
val a = Array(1,2,3,4,5,4,3,2,1)val tuple: (Array[Int], Array[Int]) = a.splitAt(4)println("第一组："+tuple._1.toList)println("第二组："+tuple._2.toList)
subSequence
定义：
def subSequence(start : scala.Int, end : scala.Int) : java.lang.CharSequence = { /* compiled code */ }
描述：类比 slice，slice 是对于数组的，subSequence是对于字符数组，返回 start 和 end 间的字符序列，不包含 end 处的元素
示例：
val a = Array('a','b','c','d')val sequence: CharSequence = a.subSequence(1, 2)println(sequence)
10.转换类函数
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 */ }
描述：对当前序列的每个元素进行操作,可以理解成降维，最低到一维，也可以对一维数组操作，但每一个元素应该都返回一个序列，结果放入新序列返回，参数要求是 GenTraversableOnce 及其子类，即返回可迭代的集合
示例：
val a = Array(Array(1,2,3),Array(2,3,4))val ints: Array[Int] = a.flatMap(x=>x)println(ints.toList)
flatten
定义：
def flatten[U](implicit asTrav : scala.Function1[T, scala.collection.Traversable[U]], m : scala.reflect.ClassTag[U]) : scala.Array[U] = { /* compiled code */ }
描述：扁平化，将二维数组的所有元素组合在一起，形成一个一维数组返回
示例：
val a = Array(Array(1,2,3),Array(2,3,4))println(a.flatten.toList)
iterator
定义：
override def iterator : scala.collection.Iterator[A] = { /* compiled code */ }
描述：生成当前序列的迭代器
示例：
val a = Array(1,2,3)val iterator: Iterator[Int] = a.iteratorprintln(iterator.getClass.getName+" ; "+iterator.toList)
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 ints: Array[Int] = a.map(x => x + 2)println(ints.toList)
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 ints: Array[Int] = a.reverseMap(x => x + 2)println(ints.toList)
toArray
定义：
def toArray[B >: A](implicit evidence$1 : scala.reflect.ClassTag[B]) : scala.Array[B] = { /* compiled code */ }
描述：将序列转换成 Array 类型
示例：
val a = List(1,2,3,4)val array: Array[Int] = a.toArray
toBuffer
定义：
def toBuffer[B >: A] : scala.collection.mutable.Buffer[B] = { /* compiled code */ }
描述：将序列转换成 Buffer 类型
示例：
val a = List(1,2,3,4)val buffer: mutable.Buffer[Int] = a.toBuffertoIndexedSeq
定义：
def toIndexedSeq : scala.collection.immutable.IndexedSeq[A] = { /* compiled code */ }
描述：将序列转换成 IndexedSeq 类型
示例：
val a = List(1,2,3,4)val seq: immutable.IndexedSeq[Int] = a.toIndexedSeq
toIterable
定义：
override def toIterable : scala.collection.Iterable[A] = { /* compiled code */ }
描述：将序列转换成【可重复迭代】的类型
示例：
val a = List(1,2,3,4)val iterable: Iterable[Int] = a.toIterabletoIterator
定义：
override def toIterator : scala.collection.Iterator[A] = { /* compiled code */ }
描述：将序列转换成迭代器，同 iterator 方法
示例：
val a = List(1,2,3,4)val iterator: Iterator[Int] = a.toIteratortoList
定义：
override def toList : scala.List[A] = { /* compiled code */ }
描述：将序列转换成 List 类型
示例：
val a = Array(1,2,3,4)val list: List[Int] = a.toListtoMap
定义：
def toMap[T, U](implicit ev : _root_.scala.Predef.<:<[A, scala.Tuple2[T, U]]) : scala.collection.immutable.Map[T, U] = { /* compiled code */ }
描述：将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型
示例：
val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))val map: Map[Int, String] = a.toMaptoSeq
定义：
override def toSeq : scala.collection.Seq[A] = { /* compiled code */ }
描述：将序列转换成 Seq 类型
示例：
val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))val seq: Seq[(Int, String)] = a.toSeq
toSet
定义：
def toSet[B >: A] : scala.collection.immutable.Set[B] = { /* compiled code */ }
描述：将序列转换成 Set 类型
示例：
val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))val set: Set[(Int, String)] = a.toSet
toStream
定义：
override def toStream : scala.collection.immutable.Stream[A] = { /* compiled code */ }
描述：将序列转换成 Stream 类型
val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))val stream: Stream[(Int, String)] = a.toStreamtoVector
定义：
def toVector : scala.Vector[A] = { /* compiled code */ }
描述：将序列转换成 Vector 类型
示例：
val a = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))val vector: Vector[(Int, String)] = a.toVectortranspose
定义：
def transpose[U](implicit asArray : scala.Function1[T, scala.Array[U]]) : scala.Array[scala.Array[U]] = { /* compiled code */ }
描述：矩阵转置，二维数组行列转换
示例：
val a = Array(Array(11,12,13),Array(21,22,23))val transpose: Array[Array[Int]] = a.transposetranspose.foreach(x=>println(x.mkString(",")))
seq
定义：
def seq : scala.collection.mutable.IndexedSeq[T] = { /* compiled code */ }
描述：产生一个引用当前序列的 sequential 视图
示例：
val a = Array(1,2,3,4)val seq: mutable.IndexedSeq[Int] = a.seqprintln(seq)
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 */ }
描述：将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组
示例：
val a = Array((1,2),(3,4),(5,6))val unzip: (Array[Int], Array[Int]) = a.unzipprintln("元组的_1 : "+unzip._1.toList)println("元组的_2 : "+unzip._2.toList)
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 */ }
描述：将含有三个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组
示例：
val a = Array((1,2,3),(4,5,6),(7,8,9))val unzip: (Array[Int], Array[Int], Array[Int]) = a.unzip3println("元组的_1 : "+unzip._1.toList)println("元组的_2 : "+unzip._2.toList)println("元组的_3 : "+unzip._3.toList)
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')val index: Array[(Char, Int)] = a.zipWithIndexprintln(index.mkString(",")) 
11.工具类函数
addString(b)
定义：
def addString(b : scala.StringBuilder) : scala.StringBuilder = { /* compiled code */ }
描述：将数组中的元素逐个添加到 StringBuilder 中
示例：
val a = Array(1,2,3)val b = new StringBuildera.addString(b)println(b)
addString(b, sep)
定义：
def addString(b : scala.StringBuilder, sep : _root_.scala.Predef.String) : scala.StringBuilder = { /* compiled code */ }
描述：将数组中的元素逐个添加到 StringBuilder 中，每个元素用 sep 分隔符分开
示例：
val a = Array(1,2,3)val b = new StringBuildera.addString(b,",")println(b)
distinct
定义：
def distinct : Repr = { /* compiled code */ }
描述：去除当前集合中重复的元素，只保留一个,返回去重后的集合
示例：
val a = Array(1,2,3,2,1)val distinct: Array[Int] = a.distinctprintln(distinct.toList)
indices
定义：
def indices : scala.collection.immutable.Range = { /* compiled code */ }
描述：返回当前序列索引集合
示例：
val a = Array(1,2,3,2,1)val indices: Range = a.indicesprintln(indices)
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 ，则返回当前序列，并不会截取当前序列
示例：填充一个长度为 7 的序列，不足位补 0，填充长度为 2 返回原序列
val a = Array(1,2,3)val ints: Array[Int] = a.padTo(7, 0)val ints1: Array[Int] = a.padTo(2, 0)println(ints.toList)println(ints1.toList)
prefixLength
定义：
def prefixLength(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }
描述：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
示例：
val a = Array(1,2,3,2,1)val i: Int = a.prefixLength(x => x < 3)println(i)
mkString
定义：
def mkString : _root_.scala.Predef.String = { /* compiled code */ }
描述：将序列中所有元素拼接成一个字符串
示例：
val a = Array(1,2,3,2,1)println(a.mkString)
mkString(sep)
定义：
def mkString(sep : _root_.scala.Predef.String) : _root_.scala.Predef.String = { /* compiled code */ }
描述：将序列中所有元素拼接成一个字符串，以 sep 作为元素间的分隔符
示例：
val a = Array(1,2,3,2,1)println(a.mkString(","))
mkString(start, sep, end)
定义：
def mkString(start : _root_.scala.Predef.String, sep : _root_.scala.Predef.String, end : _root_.scala.Predef.String) : _root_.scala.Predef.String = { /* compiled code */ }
描述：将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾
示例：
val a = Array(1,2,3,2,1)println(a.mkString("(",",",")"))
length
定义：
def length : scala.Int = { /* compiled code */ }
描述：返回序列元素个数
示例：
val a = Array(1,2,3,2,1)val length: Int = a.lengthprintln(length) 
lengthCompare
定义：
override def lengthCompare(len : scala.Int) : scala.Int = { /* compiled code */ }
描述：比较序列的长度和参数 len，返回：序列的长度 length- 参数len
示例：
val a = Array(1, 2, 3, 4)
println(a.lengthCompare(3)) // 1
println(a.lengthCompare(4)) // 0
println(a.lengthCompare(5)) // -1
size
定义：
override def size : scala.Int = { /* compiled code */ }
描述：返回序列元素个数，同 length
示例：
val a = Array(1, 2, 3, 4)val size: Int = a.sizeprintln(size) 
stringPrefix
定义：
def stringPrefix : _root_.scala.Predef.String = { /* compiled code */ }
描述：返回 toString 结果的前缀
示例：
val a = List(1,2,3)println(a.toString())println(a.stringPrefix)
12.集合内与集合间计算函数
aggregate
定义：
def aggregate[B](z : => B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B = { /* compiled code */ }
描述：聚合计算，aggregate 是柯里化方法，参数是两个方法
示例：为了方便理解，把 aggregate 的两个参数分别封装成两个方法，并把分区和不分区的计算过程分别打印出来
def seq(m:Int,n:Int):Int={println("seq:"+m+"+"+n)m+n}def combine(m:Int,n:Int):Int={println("combine:"+m+"+"+n)m+n}val a = Array(1,2,3,4)println("不分区情形：")val i: Int = a.aggregate(5)(seq, combine) //不分区println("不分区的 i = "+i)println("===================================")println("分区情形：")val i1: Int = a.par.aggregate(5)(seq, combine) //分区println("分区的 i1 = "+i1)
通过上面的运算不难发现，不分区时，seqno 是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算。
分区时，seqno 是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法 combine 进行处理。
上面过程可以简写为
val b = a.aggregate(5)(_+_,_+_) // 不分区
val c = a.par.aggregate(5)(_+_,_+_) // 分区fold
定义：
def fold[U >: T](z : U)(op : scala.Function2[U, U, U]) : U = { /* compiled code */ }
描述：对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同，fold类的函数，分区内的计算逻辑就是分区间的计算逻辑，而aggregate却可以指定分区内的计算逻辑与分区间的计算逻辑，此外，fold方法要求聚合的两者类型相同【map聚合时会被当做元组】，而foldLeft和foldRight则不必
示例：
def seq(m:Int,n:Int):Int={println("seq:"+m+"+"+n)m+n}val a = Array(1,2,3,4)println("不分区情形：")val i: Int = a.fold(5)(seq) //不分区println("不分区的 i = "+i)println("===================================")println("分区情形：")val i1: Int = a.par.fold(5)(seq) //分区println("分区的 i1 = "+i1)
foldLeft 可简写为 /:
定义：
def foldLeft[S](z : S)(op : scala.Function2[S, T, S]) : S = { /* compiled code */ }
描述：从左到右计算，简写方式：
示例：
def seq(m:Int,n:Int):Int={println("seq:"+m+"+"+n)m+n}val a = Array(1,2,3,4)val i: Int = a.foldLeft(5)(seq) // 也可简写：(5 /: a)(_ + _)println("i = "+i)
foldRight 可简写为 :/
定义：
override def foldRight[B](z : B)(op : scala.Function2[A, B, B]) : B = { /* compiled code */ }
描述：从右到左计算，简写方式：
示例：
def seq(m:Int,n:Int):Int={println("seq:"+m+"+"+n)m+n}val a = Array(1,2,3,4)val i: Int = a.foldRight(5)(seq) // 也可简写：(a :/ 5)(_ + _)println("i = "+i)
reduce
定义：
描述：不需要初始值，在集合内部进行聚合运算
示例：
val a = Array(1,2,3,4)val i: Int = a.reduce((x,y)=>{println("seq:"+x+"+"+y)x+y})println("i = "+i)
reduceLeft
val a = Array(1,2,3,4)val i: Int = a.reduceLeft((x,y)=>{println("seq:"+x+"+"+y)x+y})println("i = "+i)定义：
override def reduceLeft[B >: A](op : scala.Function2[B, A, B]) : B = { /* compiled code */ }
描述：同 foldLeft，从左向右计算，不需要初始值
示例：
reduceRight
定义：
override def reduceRight[B >: A](op : scala.Function2[A, B, B]) : B = { /* compiled code */ }
描述：同 foldRight，从右向左计算，不需要初始值
示例：
val a = Array(1,2,3,4)val i: Int = a.reduceRight((x,y)=>{println("seq:"+x+"+"+y)x+y})println("i = "+i)
reduceLeftOption
定义：
def reduceLeftOption[B >: A](op : scala.Function2[B, A, B]) : scala.Option[B] = { /* compiled code */ }
描述：同 reduceLeft，返回 Option
示例：
val a = Array(1,2,3,4)val i: Option[Int] = a.reduceLeftOption((x, y) => {println("seq:" + x + "+" + y)x + y})println("i = "+i)
reduceRightOption
定义：
def reduceRightOption[B >: A](op : scala.Function2[A, B, B]) : scala.Option[B] = { /* compiled code */ }
描述：同 reduceRight，返回 Option
示例：
val a = Array(1,2,3,4)val i: Option[Int] = a.reduceRightOption((x, y) => {println("seq:" + x + "+" + y)x + y})println("i = "+i)
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 返回的是最后的结果
示例：
val a = Array(1,2,3,4)val i: Array[Int] = a.scan(5)((x, y) => {println("seq:" + x + "+" + y)x + y})println("i = "+i.mkString("(",",",")"))
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，从左向右计算，每一步的计算结果放到一个新的集合中返回
示例：
val a = Array(1,2,3,4)val i: Array[Int] = a.scanLeft(5)((x, y) => {println("seq:" + x + "+" + y)x + y})println("i = "+i.mkString("(",",",")"))
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，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回
示例：
val a = Array(1,2,3,4)val i: Array[Int] = a.scanRight(5)((x, y) => {println("seq:" + x + "+" + y)x + y})println("i = "+i.mkString("(",",",")"))
diff
定义：
def diff[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }
描述：计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回
示例：
val a = Array(1,2,3)val b = Array(2,3,4)val a_diff_b: Array[Int] = a.diff(b)println(a_diff_b.toList)
intersect
定义：
def intersect[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }
描述：取两个集合的交集
示例：
val a = Array(1,2,3)val b = Array(2,3,4)val a_intersect_b: Array[Int] = a.intersect(b)println(a_intersect_b.toList)
union
定义：
override def union[B >: A, That](that : scala.collection.GenSeq[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }
描述：合并两个序列，同操作符 ++
示例：
val a = Array(1,2,3)val b = Array(2,3,4)val a_union_b: Array[Int] = a.union(b)println(a_union_b.toList)
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 */ }
描述：将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同
示例：
val a = Array(1,2,3)val b = Array(2,3,4)val a_zip_b: Array[(Int, Int)] = a.zip(b)println(a_zip_b.toList)
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)val b = Array(2,3,4)val a_zipAll_b: Array[(Int, Int)] = a.zipAll(b,1,0)println(a_zipAll_b.toList)val b_zipAll_a: Array[(Int, Int)] = b.zipAll(a,1,0)println(b_zipAll_a.toList)
