定义：def ++[B](that: GenTraversableOnce[B]): Array[B] 描述：合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。
val a = Array(1,2,3) val b = Array(4,5,6) val c = a ++ b //c中的内容是(1,2,3,4,5,6)定义：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That 描述：与上个方法类似，但是该方法右边操纵数的类型决定着返回结果的类型。下面代码中List和LinkedList结合，返回结果是LinkedList类型
val a = List(1,2,3) val b = scala.collection.mutable.LinkedList(4,5,6) val c = a ++: b println(c.getClass().getName()) //c的类型是:scala.collection.mutable.LinkedList定义：def +:(elem: A): Array[A] 描述：在数组前面添加一个元素，并返回新的对象
val a = List(1,2,3) val c = 0 +: a // c中的内容是 （0,1,2）定义：def :+(elem: A): Array[A] 描述：同上面的方法想法，在数组末尾添加一个元素，并返回新对象
val a = List(1,2,3) val c = a :+ 0 // c中的内容是 （1,2,3,0）定义：def /:[B](z: B)(op: (B, T) ⇒ B): B 描述：对数组中所有的元素进行相同的操作 ，foldLeft的简写，操作从右往左进行
val a = List(1,2,3,4) // 将函数执行的每一步都输出 val c = (10/:a)((x,y)=>{println(x,y);x+y})定义：def :[B](z: B)(op: (T, B) ⇒ B): B 描述：对数组中所有的元素进行相同的操作，foldRight的简写，操作从左向右进行
val a = List(1,2,3,4) val c = (a:\10)((x,y)=>{println(x,y);x+y})注意：集合放置在冒号一侧
定义：def addString(b: StringBuilder): StringBuilder 描述：将数组中的各个元素添加到StringBuilder中
val a =List(1,2,3,4) // 无分隔符 val b = new StringBuilder a.addString(b) // 指定分隔符 val c = new StringBuilder a.addString(c,"&") // 指定分隔符，并在前后分别添加指定符号 val d = new StringBuilder a.addString(d,"{","&","}")定义：def aggregate[B](z: => B)(seqop: (B, Int) => B,combop: (B, B) => B): B 描述：聚合计算，aggregate是柯里化方法，参数是两个方法
// 写法一 def seqop(x:Int,y:Int):Int={ // seqop用于分区内操作 println("seqop",x,y) x+y } def combop(x:Int,y:Int):Int={ // combop用于分区间操作 println("combop",x,y) x+y } // par相当于多线程或分片 a.par.aggregate(5)(seqop,combop) // 写法二 a.par.aggregate(5)((x,y)=>{println("seqop",x,y);x+y},(x,y)=>{println("combop",x,y);x+y}) // 写法三 a.par.aggregate(5)(_+_,_+_)定义：def apply(i: Int): T 描述：取出指定索引处的元素；可以是数组，也可以是集合
val a = Array(1,2,3,4) val c = a.apply(2) // c为3 // 等同于下列语句 val d = a(2)定义：def canEqual(that: Any): Boolean 描述：判断两个对象是否可以进行比较
val a = Array(1,2,3,4) val b = Array(1,2,3) val c = a.canEqual(b) // c:Boolean = True定义：def charAt(index: Int): Char 描述：获取index索引处的字符，但类型必须为char类型
val chars = Array('a','b','c') val c = chars.charAt(0) // c的值为a val a = Array(1,2,3) val c = a.charAt(0) // 报错定义：def clone(): Array[T] 描述：创建一个副本
val chars = Array('a','b','c') val newchars = chars.clone() // c为Array[Char] = Array(a, b, c) // 当原副本中包含对象时，clone拷贝的是对象的引用 var a = Array(1,2,3) var b = Array(1,2,3,a) var c=b.clone a(1)=4 b c定义：def collect[B](pf: PartialFunction[A, B]): Array[B] 描述：通过执行一个偏函数，得到一个新的数组对象
val chars = Array('a','b','c') val fun:PartialFunction[Char,Char]={ case 'a'=>'A' case 'b'=>'B' case x => x } chars.collect(fun)定义：def collectFirst[B](pf: PartialFunction[T, B]): Option[B] 描述：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
val arr = Array("0",2,"a",'B') val fun:PartialFunction[Any,Int]={ case x:Int => x*100 } val a = arr.collectFirst(fun) val b = arr.collectFirst({case x:Int => x*100})定义：def combinations(n: Int): collection.Iterator[Array[T]] 描述：排列组合，排列组合会选出所有包含字符不一样的组合,不包括元素重复顺序不同，参数用于指定组合元素个数，返回的是迭代器
val arr = Array("a","b","c","d") val a = arr.combinations(2) a.foreach(x=>println(x.mkString))定义：def contains[A1 >: A](elem: A1): Boolean 描述：数组中是否包含指定元素
val arr = Array("a","b","c","d") arr.contains("a") arr.contains("f")定义：def containsSlice[B](that: GenSeq[B]): Boolean 描述：判断当前序列中是否包含另一个序列
val a = List(1,2,3,4) val b = List(1,2) val c = List(2,1) val d = List(1,4) a.containsSlice(b) a.containsSlice(c) a.containsSlice(d)定义：def copyToArray(xs: Array[A]): Unit 描述：拷贝内容到数组
val a = Array(1,2,3,4) val b:Array[int] = new Array(6) val c:Array[int] = new Array(6) val d:Array[int] = new Array(6) val e:Array[int] = new Array(6) a.copyToArray(b) // b:Array[Int] = Array(1, 2, 3, 4, 0, 0) // 指定插入位置，超出数组范围部分截掉 a.copyToArray(c,1) // c:Array[Int] = Array(0, 1, 2, 3, 4, 0) a.copyToArray(d,3) // d:Array[Int] = Array(0, 0, 0, 1, 2, 3) // 指定插入位置和插入长度 a.copyToArray(e,1,2) // e:Array[Int] = Array(0, 1, 2, 0, 0, 0)定义：def copyToBuffer[B >: A](dest: Buffer[B]): Unit 描述：将数组中的内容拷贝到Buffer中
import scala.collection.mutable.ArrayBuffer val a = Array(1,2,3,4) val b:ArrayBuffer[Int] = ArrayBuffer() a.copyToBuffer(b) println(b.mkString(","))定义：def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean 描述： 判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true
val a = Array(1,2,3) val b = Array(4,5,6) val c = Array(4,1,6) val d = Array(4,5,6,7) a.corresponds(b)(_<_) a.corresponds(c)(_<_) a.corresponds(d)(_<_)定义：def count(p: (T) ⇒ Boolean): Int 描述：统计符合条件的元素个数，需要传递一个条件
val a = Array(1,2,3) a.count(x=>x>1) a.size // 用size计算长度定义：def diff(that: collection.Seq[T]): Array[T] 描述：计算当前数组与另一个数组的不同。
// 将当前数组中没有在另一个数组中出现的元素返回 val a = Array(1, 2, 3, 4) val b = Array(4, 5, 6, 7) val c = a.diff(b)定义：def distinct: Array[T] 描述：去除当前集合中重复的元素，只保留一个
val a = Array(1, 2, 3, 3, 4, 4, 5, 6, 6) val c = a.distinct定义：def drop(n: Int): Array[T] 描述：将当前序列中前 n 个元素去除后，作为一个新序列返回
val a = Array(1,1,2,2,3,3,4,4) val c = a.drop(3)定义：def dropRight(n: Int): Array[T] 描述：去掉尾部的 n 个元素
val a = Array(1,1,2,2,3,3,4,4) val c = a.dropRight(3)定义：def dropWhile(p: (T) ⇒ Boolean): Array[T] 描述：去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组
// 去除大于2的元素，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 2,3,4 val a = Array(3, 2, 3,4) val b = a.dropWhile( {x:Int => x > 2} ) // 如果数组 a 是下面这样，第一个元素就不满足，所以返回整个数组 1, 2, 3,4 val a = Array(1, 2, 3,4)定义：def endsWith[B](that: GenSeq[B]): Boolean 描述：判断是否以某个序列结尾，注意参数必须为序列，为单值会报错
val a = Array(1,2,3,4) val b = Array(3,4) a.endsWith(b)定义：def exists(p: (T) ⇒ Boolean): Boolean 描述：判断当前数组是否包含符合条件的元素
val a = Array(1,2,3,4) a.exists(_==3) a.exists(x=>x==2) a.exists(_==5)定义：def filter(p: (T) ⇒ Boolean): Array[T] 描述：取得当前数组中符合条件的元素，组成新的数组返回
val a = Array(1,2,3,4) val c = a.filter(x=>x>2)定义：def filterNot(p: (T) ⇒ Boolean): Array[T] 描述：与 filter 的作用相反
val a = Array(1,2,3,4) val c = a.filterNot(x=>x>2)定义：override def find(p: Int => Boolean): Option[Int] 描述：查找第一个符合条件的元素
val a = Array(1, 2, 3, 4) val b = a.find(x=>x>2) // b: Option[Int] = Some(3)定义：def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B] 描述：对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类
// 案例一 val a = Array(1,2,3,4) val b = a.flatMap(1 to _) // 案例二 val c = List("hello java","hello scala","hello hadoop") val d = a.flatMap(x=>x.split(" "))定义：def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U] 描述：降维；将二维数组的所有元素联合在一起，形成一个一维数组返回
val a = Array(Array(1,2,3),Array(4,5,6)) val b = Array(Array("a","b","c"),Array("d","e","f")) a.flatten b.flatten定义：def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1 描述：对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同。默认是foldLeft
val a = Array(1,2,3,4) a.fold(5)(_+_) a.fold(5)((x,y)=>{println(x,y);x+y})定义：def foldLeft[B](z: B)(op: (B, T) ⇒ B): B 描述：从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) ⇒ B): B
val a = Array(1,2,3,4) a.foldLeft(5)((x,y)=>{println(x,y);x+y}) // 简写 (5/:a)((x,y)=>{println(x,y);x+y})定义：def foldRight[B](z: B)(op: (B, T) ⇒ B): B 描述：从右到左计算，简写方式：def :[B](z: B)(op: (T, B) ⇒ B): B
val a = Array(1,2,3,4) a.foldRight(5)((x,y)=>{println(x,y);x+y}) (a:\5)((x,y)=>{println(x,y);x+y})定义：def forall(p: (T) ⇒ Boolean): Boolean 描述：检测序列中的元素是否都满足条件 p，若都满足，返回true
val a = Array(1,2,3,4) val b = Array(1,2,3,4) a.forall({x=>x>0}) b.forall({x=>x>1})定义：def foreach(f: (A) ⇒ Unit): Unit 描述：遍历序列中的元素，进行 f 操作
val a = Array(1,2,3,4) a.foreach(x=>println(x>2))定义：def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]] 描述：按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列
val a = Array(1,2,3,4) val b = a.groupBy(x=>x) val c = a.groupBy(x=>x match{ case x if(x<3) => "small" case x if(x==3) => "equal" case x if(x>3) => "big" }) c.foreach(x=>println(x._1,x._2.toList))定义：def grouped(size: Int): collection.Iterator[Array[T]] 描述：按指定数量分组，每组有 size 数量个元素，返回一个集合
val a = Array(1,2,3,4,5) val b = a.grouped(2) b.foreach(x=>println(x.mkString))定义：def hasDefiniteSize: Boolean 描述：如果声明的集合的大小有限，则返回true，否则返回false，或者如果迭代器为空，则返回true，否则返回false。如果是流stream数据，则返回false
val a = Array(1,2,3,4,5) println(a.hasDefiniteSize)定义：def head: T 描述：返回序列的第一个元素，如果序列为空，将引发错误
val a = Array(1,2,3,4,5) a.head // 取第一个元素 a.tail // 取除第一个元素以外的其他元素定义：def headOption: Option[T] 描述：返回Option类型对象，即Some 或者 None，如果序列是空，返回None
val a = Array(1,2,3,4,5) val b:Array[Int] = Array() a.headOption b.headOption定义：def indexOf(elem: T, from: Int): Int 描述：返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回
val a = Array(1,2,3,4,3,2,1) a.indexOf(1) // 指定查找位置 a.indexOf(3,3)定义：def indexOfSlice[B >: A](that: GenSeq[B]): Int 描述：检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，若不匹配则返回-1
val a = Array(1,2,3,4,5,6) val d = Array(3,4,5) a.indexOfSlice(d) // 指定查找开始位置 a.indexOfSlice(d,1) a.indexOfSlice(d,3)定义：def indexWhere(p: (T) ⇒ Boolean): Int 描述：返回当前序列中第一个满足 p 条件的元素的索引
val a = Array(1,2,3,4,5,6) a.indexWhere(x=>x>3) // 指定开始下标 a.indexWhere(x=>x>3,4)定义：def indices: collection.immutable.Range 描述：返回当前序列索引集合
val a = Array(1,2,3,4,5,6) a.indices定义：def init: Array[T] 描述：返回当前序列中不包含最后一个元素的序列
val a = Array(1,2,3,4,5,6) a.init定义：def inits: collection.Iterator[Array[T]] 描述：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象
val a = Array(1,2,3,4,5,6) a.inits.toList定义：def intersect(that: collection.Seq[T]): Array[T] 描述：取两个集合的交集
val a = Array(1,2,3,4,5,6) val b = Array(2,4,8) a.intersect(b)定义：def isDefinedAt(idx: Int): Boolean 描述：判断序列中是否存在指定索引
val a = Array(1,2,3,4,5,6) a.isDefinedAt(1) a.isDefinedAt(7)定义：def isEmpty: Boolean 描述：判断当前序列是否为空
val a = Array(1,2,3,4,5,6) val b:Array[Int] = Array[Int]() a.isEmpty b.isEmpty定义：def isTraversableAgain: Boolean 描述：判断序列是否可以反复遍历，对于 Iterators返回 false
val a = Array(1,2,3,4,5,6) a.isTraversableAgain定义：def iterator: collection.Iterator[T] 描述：对序列中的每个元素产生一个 iterator
val a = Array(1,2,3,4,5,6) a.iterator //此时就可以通过迭代器访问 a.iterator.toList定义：def last: T 描述：取得序列中最后一个元素
val a = Array(1,2,3,4,5,6) a.last定义：def lastIndexOf(elem: T): Int 描述：取得序列中最后一个等于 elem 的元素的位置
val a = Array(1,2,3,1,2,3,5,6,7,8,3) a.indexOf(3) a.lastIndexOf(3) // 指定查找结束的位置（下标） a.lastIndexOf(3,8)定义：def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int 描述：判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引
val a = Array(1,2,3,4,5) val b = Array(1,2) a.lastIndexOfSlice(b)定义：def lastIndexWhere(p: (T) ⇒ Boolean): Int 描述：返回当前序列中最后一个满足条件 p 的元素的索引
val a = Array(1,2,3,4,5,6,7) a.lastIndexWhere(x=>x<5) // 指定结束的下标 a.lastIndexWhere(x=>x<5,2)定义：def lastOption: Option[T] 描述：返回当前序列中最后一个对象
val a = Array(1,2,3,1,2,3) val b = Array(Array(1,2),Array(3,4),Array(5,6)) a.lastOption b.lastOption定义：def length: Int 描述：返回当前序列中元素个数
val a = Array(1,2,3,1,2,3) a.length定义：def lengthCompare(len: Int): Int 描述：比较序列的长度和参数 len，根据二者的关系返回不同的值
val a = Array(1,2,3,1,2,3) a.length a.lengthCompare(6) // 6-6 a.lengthCompare(9) // 6-9 a.lengthCompare(3) // 6-3定义：def map[B](f: (A) ⇒ B): Array[B] 描述：对序列中的元素进行 f 操作
val a = Array(1,2,3,4,5,6) a.map(x=>(x,1)) a.map(x=>x+1)定义：def max: A 描述：返回序列中最大的元素
val a = Array(1,2,3,1,2,3) a.max定义：def maxBy[B](f: (A) ⇒ B): A 描述：返回序列中第一个符合条件的最大的元素，当都不满足是返回第一个元素
val a = Array(1,2,3,1,2,3) a.maxBy(_>2) a.maxBy(_>1) a.maxBy(_>3)定义：def max: A 描述：返回序列中最小的元素
val a = Array(1,2,3,1,2,3) a.min定义：def minBy[B](f: (A) ⇒ B): A 描述：返回序列中不符合条件的第一个元素
val a = Array(1,2,3,1,2,3) a.minBy(x=>x<2) a.minBy(x=>x<1)定义：def mkString: String 描述：将所有元素组合成一个字符串
val a = Array(1,2,3,4) a.mkString // 指定分隔符 a.mkString(",") // 指定分隔符，并在首尾添加指定符号 a.mkString("{",",","}")定义：def nonEmpty: Boolean 描述：判断序列不为空，不为空返回true，反之返回false
val a = Array(1,2,3,4) val b:Array[Int] = Array[Int]() a.nonEmpty b.nonEmpty定义：def padTo(len: Int, elem: A): Array[A] 描述：补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，用 elem填充空值，如果当前序列大于等于 len ，则返回当前序列
val a = Array(1,2,3,4) a.padTo(6,5) a.padTo(4,5)定义：def par: ParArray[T] 描述：返回一个并行实现，即并行实现要执行的方法，产生的并行序列，不能被修改
val a = Array(1,2,3,4,5) a.foreach(println) a.par.foreach(println)定义：def partition(p: (T) ⇒ Boolean): (Array[T], Array[T]) 描述：按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列
val a = Array(1,2,3,4,5) a.partition(x=>x%3==1)定义：def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A] 描述：批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that
val a = Array(1,2,3,4,5,6,7,8) val b = Array(11,12,13) a.patch(3,b,1) a.patch(3,b,2) a.patch(3,b,6)定义：def permutations: collection.Iterator[Array[T]] 描述：排列组合，组合中的内容可以相同，但是顺序不能相同，在这点与combinations有所区别
val a = Array(1,2,3) a.permutations.toList a.combinations(3).toList定义：def prefixLength(p: (T) ⇒ Boolean): Int 描述：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
val a = Array(1,2,4,8,6,5,4) a.prefixLength(x=>x<5) // 1 2 4满足条件，故返回3定义：def product: A 描述：返回所有元素乘积的值
val a = Array(1,2,3,4,5) a.product定义：def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1 描述：与 fold相似，不需要初始值
val a = Array(1,2,3,4,5) a.reduce((x,y)=>{println(x,y);x+y}) a.fold(5)((x,y)=>{println(x,y);x+y}) a.reduce(_+_) a.fold(5)(_+_)定义：def reduceLeft[B >: A](op: (B, T) ⇒ B): B 描述：同reduce,从左向右计算
val a = Array(1,2,3,4,5) a.reduceLeft((x,y)=>{println(x,y);x+y})定义：def reduceRight[B >: A](op: (T, B) ⇒ B): B 描述：从右向左计算
val a = Array(1,2,3,4,5) a.reduceRight((x,y)=>{println(x,y);x+y})定义：def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B] 描述：同 reduceLeft，返回 Option
val a = Array(1,2,3,4,5) a.reduceLeftOption(_+_)定义：def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B] 描述：同 reduceRight，返回 Option
val a = Array(1,2,3,4,5) a.reduceRightOption(_+_)定义：def reverse: Array[T] 描述：反转序列
val a = Array(1,2,3,4,5) a.reverse定义：def reverseIterator: collection.Iterator[T] 描述：生成反向迭代器
val a = Array(1,2,3,4,5) a.reverseIterator a.reverseIterator.foreach(println)定义：def reverseMap[B](f: (A) ⇒ B): Array[B] 描述：同 map，序列的顺序倒置
val a = Array(1,2,3,4,5) a.reverseMap(x=>x*10) a.reverseMap(_*10)定义：def sameElements(that: GenIterable[A]): Boolean 描述：判断两个序列是否顺序和对应位置上的元素都一样，且两个序列的长度必须一致，否则结果为false
val a = Array(1,2,3,4,5) val b = Array(1,2,3,4,5) val c = Array(1,2,3,4,5,6) a.sameElements(b) a.sameElements(c)定义：def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That 描述：同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果
val a = Array(1,2,3,4,5) a.scan(9)((x,y)=>{println(x,y);x+y}) a.scan(9)(_+_) a.fold(9)(_+_)定义：def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That 描述：同 foldLeft，从左向右计算，每一步的计算结果放到一个新的集合中返回
val a = Array(1,2,3,4,5) a.scanLeft(9)((x,y)=>{println(x,y);x+y})定义：def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That 描述：同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回
val a = Array(1,2,3,4,5) a.scanRight(9)((x,y)=>{println(x,y);x+y})定义：def segmentLength(p: (T) ⇒ Boolean, from: Int): Int 描述：从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个
val a = Array(1,2,3,4,5,6) a.segmentLength(x=>{x<5},0) a.segmentLength(x=>{x<5},2)定义：def seq: collection.mutable.IndexedSeq[T] 描述：产生一个引用当前序列的 sequential 视图
val a = Array(1,2,3,4,5,6) a.seq a.seq.foreach(println)定义：def size: Int 描述：返回序列元素个数，同 length
val a = Array(1,2,3,4,5,6) a.size a.length定义：def slice(from: Int, until: Int): Array[T] 描述：取出当前序列中，from 到 until 之间的片段
val a = Array(1,2,3,4) a.slice(1,3) a.slice(0,5)定义：def sliding(size: Int): collection.Iterator[Array[T]] 描述：按照顺序从左向右一个一个滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组(数组长度为3)，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束
val a = Array(1,2,3,4,5,6,7,8,9,10) a.sliding(3).toList // 第二个参数为步长 a.sliding(3,3).toList定义：def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T] 描述：按指定的排序规则对序列排序
val a = Array(1,2,3,4,5,6,7,8,9,10) a.sortBy(x=>x) a.sortBy(x=>{-x}) // 倒序定义：def sortWith(lt: (T, T) ⇒ Boolean): Array[T] 描述：自定义排序方法 对序列排序
val a = Array(1,2,3,4,5,6,7,8,9,10) a.sortWith((x,y)=>{println(x,y);x.compareTo(y)>0}) // 逆序 a.sortWith((x,y)=>{x.compareTo(y)<0}) // 正序定义：def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]] 描述：使用默认的排序规则对序列排序
val a = Array(("hello",4),("world",1),("scala",3),("java",6)) val b = Array(5,4,3,2,1) a.sorted b.sorted定义：def span(p: (T) ⇒ Boolean): (Array[T], Array[T]) 描述：将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，满足的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
val a = Array(1,2,4,3,5) a.span(x=>x<4)定义：def splitAt(n: Int): (Array[T], Array[T]) 描述：从指定位置开始，把序列拆分成两个数组(该指定位置的元素划分到第二个数组中)
val a = Array(1,2,3,4,5,6,7,8,9,10) a.splitAt(5)定义：def startsWith[B](that: GenSeq[B]): Boolean 描述：判断序列是否以某个序列开始
val a = Array(1,2,3,4,5,6,7,8,9,10) val b = Array(6,7,8) a.startsWith(b) // 指定开始的位置 a.startsWith(b,5)定义：def stringPrefix: String 描述：返回 toString 结果的前缀
val a = Array(1,2,3,4,5,6,7,8,9,10) val b = List(1,2,3,4) a.toString a.stringPrefix b.toString b.stringPrefix定义：def subSequence(start: Int, end: Int): CharSequence 描述：返回 start 和 end 间的字符序列，不包含 end 处的元素,只适用于字符数组)
val a = Array('a','b','c','d','e') val b = Array(1,2,3,4) a.subSequence(0,2) b.subSequence(0,2)定义：def sum: A 描述：序列求和
val a = Array(1,2,3,4,5,6,7,8,9,10) a.sum定义：def tail: Array[T] 描述：返回当前序列中不包含第一个元素的序列；与init相反，init去除最后一个元素
val a = Array(1,2,3,4,5,6,7,8,9,10) a.tail定义：def tails: collection.Iterator[Array[T]] 描述：同 inits，每一步都进行 tail 操作，直到null为止，并返回每一步tail操作的数组，最终返回一个集合
val a = Array(1,2,3,4) a.tails.toList a.inits.toList定义：def take(n: Int): Array[T] 描述：返回当前序列中，前 n 个元素组成的序列(从左向右)
val a = Array(1,2,3,4,5,6,7,8,9,10) a.take(2) a.take(5)定义：def takeRight(n: Int): Array[T] 描述：返回当前序列中，从右边开始，返回 n 个元素组成的序列
val a = Array(1,2,3,4,5,6,7,8,9,10) a.takeRight(2) a.takeRight(5)定义：def takeWhile(p: (T) ⇒ Boolean): Array[T] 描述：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
val a = Array(1,2,3,4,5,8,7,8,9,10) a.takeWhile(x=>x<8)定义：def toArray: Array[A] 描述：将序列转换成 Array 类型
val a = List(1,2,3,4,5) val b = "hello" a.toArray b.toArray定义：def toBuffer[A1 >: A]: Buffer[A1] 描述：将序列转换成 Buffer 类型
val a = List(1,2,3,4,5) val b = "hello" a.toBuffer b.toBuffer定义：def toIndexedSeq: collection.immutable.IndexedSeq[T] 描述：将序列转换成 IndexedSeq 类型
val a = List(1,2,3,4,5) val b = "hello" a.toIndexedSeq b.toIndexedSeq定义：def toIterable: collection.Iterable[T] 描述：将序列转换成可迭代的类型
val a = List(1,2,3,4,5) a.toIterable.foreach(println)定义：def toIterator: collection.Iterator[T] 描述：将序列转换成迭代器，同 iterator 方法
val a = List(1,2,3,4,5) a.toIterator定义：def toList: List[T] 描述：将序列转换成 List 类型
val a = Array(1,2,3,4,5) a.toList定义：def toMap[T, U]: Map[T, U] 描述：将序列转转换成 Map 类型,被转换的元素必须是元组
val a = Array(1,2,3,4,5) a.map((_,1)).toMap定义：def toSeq: collection.Seq[T] 描述：将序列转换成 Seq 类型
val a = Array(3,2,1,5,4) a.toSeq定义：def toSet[B >: A]: Set[B] 描述：将序列转换成 Set 类型
val a = Array(3,2,1,5,4) a.toSet定义：def toStream: collection.immutable.Stream[T] 描述：将序列转换成 Stream 类型
val a = Array(1,2,3,4,5) a.toStream a.toStream(1) a.toStream(2) a.toStream(0)定义：def toVector: Vector[T] 描述：将序列转换成 Vector 类型
val a = Array(1,2,3,4,5,6) a.toVector定义：def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]] 描述：矩阵转置，二维数组行列转换
val a = Array(Array("a","b"),Array("c","d"),Array("e","f"),Array("g","h")) a.transpose.foreach(x=>println(x.toList))定义：def union(that: collection.Seq[T]): Array[T] 描述：合并两个序列，功能同 ++
val a = Array(1,2,3) val b = Array(4,5,6) a.union(b)定义：def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2]) 描述：将含有若干个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组
val a = Array(("a","b"),("c","d")) a.unzip定义：def unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3]) 描述：将含有若干个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组
val a = Array(("a","b","c"),("d","e","f"),("g","h","i")) a.unzip3定义：def update(i: Int, x: T): Unit 描述：将序列中 i 索引处的元素更新为 x,改变的是序列本身
val a = Array(5,4,3,2,1,0,9) a.update(5,6) a定义：def updated(index: Int, elem: A): Array[A] 描述：将序列中 i 索引处的元素更新为 x，并返回替换后的数组
val a = Array(5,4,3,2,1,0,9) a.updated(5,6)定义：def view(from: Int, until: Int): IndexedSeqView[T, Array[T]] 描述：返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素
val a = Array(5,4,3,2,1,0,9) a.view(1,3) a.view(1,3).toList定义：def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]] 描述：根据条件 p 过滤元素
val a = Array(1,2,3,4,5) a.withFilter(x=>x>2) a.withFilter(x=>x>2).map(x=>x)定义：def zip[B](that: GenIterable[B]): Array[(A, B)] 描述：将两个序列对应位置上的元素组成一个元组数组，若两个序列长度不相同，短的序列结束则停止
val a = Array(1,2,3,4,5) val b = Array(6,7,8,9,10) val c = Array(11,12,13,14,15,16,17,18) a.zip(b) a.zip(c)定义：def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)] 描述：同 zip ，当两个序列长度不同时会自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem
val a = Array(1,2,3,4,5,100) val b = Array(6,7,8,9,10) val c = Array(11,12,13,14,15,16,17,18) a.zipAll(b,200,300) a.zipAll(c,200,300)定义：def zipWithIndex: Array[(A, Int)] 描述：序列中的每个元素和它的索引组成一个元组数组
val a = Array(1,2,3,4,5) a.zipWithIndex