scala相关函数

++

合并集合返回一个新的数组

val a=Array(1,2,3,4,5)
val b=List(1,2,8,9)
a++b//Array(1,2,3,4,5,1,2,8,9)

++：

合并集合返回一个新的数组，右边的决定返回集合的类型

val a=Array(1,2,3,4,5)
val b=List(1,2,8,9)
a++:b// List(1, 2, 3, 4, 5, 1, 2, 8, 9)

+:

在集合前面添加一个元素，返回一个新的数组对象

val a=Array(1,2,3,4,5)
1+:a// Array(1, 1, 2, 3, 4, 5)

:+

在集合后面添加一个元素，并返回新的数组

val b=List(1,2,8,9)
b:+1// List(1, 2, 8, 9, 1)

/：

对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写

val b=List(1,2,8,9)
(10 /: b) (_ + _) // (((10+1)+2)+8)+9

:\

对数组中所有的元素从右向左遍历，进行相同的迭代操作，foldRight 的简写

val b=List(1,2,8,9)
(b:\10) (_ + _) // 1+(2+(8+(9+10)))

addString()

将数组中的元素逐个添加到 StringBuilder 中

val a=Array(1,2,3,4,5)
val c=new StringBuilder()
a.addString(c)//12345

addString(b, sep)

将数组中的元素逐个添加到 StringBuilder 中，每个元素用 sep 分隔符分开

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

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 = Array(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
     */
     
    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 b = a.aggregate(5)(_+_,_+_) // 不分区
val c = a.par.aggregate(5)(_+_,_+_) // 分区

apply

获取指定索引处的元素" 下标从0开始

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

canEqual

判断两个对象是否可以进行比较" 基本所有对象都能进行比较

charAt

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

 val d=Array('a','b')
 d.charAt(0)//a

clone

创建一个副本 相当于复制，会产生一个新地址

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

collect

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

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

collectFirst

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

 val fun: PartialFunction[Any, Int] = {
      case x: Int => x * 100
    }
val d= Array(1, 'a', "b",3)
d.collectFirst(fun)//Some(100)

combinations

表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于 “abc”、“cba”，视为相同组合，参数 n 表示序列长度，就是几个字符为一组 生成的是个迭代器，只能使用一次

    val d = Array("a", "b", "c")
    val e= d.combinations(2)
    e.foreach(x => println(x.mkString(",")))
    /*
      a,b
      a,c
      b,c
     */

contains

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

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

containsSlice

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

val a = Array(1,2,3,4)
val s=Array(1,2)
a.containsSlice(s)//true

copyToArray(xs)

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

    val a = Array(1,2,3,4,5)
    val e: Array[Int] = new Array(10)
    a.copyToArray(e)
    e.foreach(println)
/*1
2
3
4
5
0
0
0
0
0*/

copyToArray(xs, start)

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

    val a = Array(1,2,3,4,5)
    val e: Array[Int] = new Array(10)
    a.copyToArray(e,4)
    e.foreach(println)
/*0
0
0
0
1
2
3
4
5
0*/

copyToArray(xs, start, len)

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

    val a = Array(1,2,3,4,5)
    val e: Array[Int] = new Array(10)
    a.copyToArray(e,4)
    e.foreach(println)
/*0
0
0
0
1
2
3
0
0
0*/

copyToBuffer

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

 import scala.collection.mutable.ArrayBuffer
   val a = Array(1,2,3,4,5)
   val e: ArrayBuffer[Int] = ArrayBuffer()
   a.copyToBuffer(e)
   e.foreach(println)

corresponds

判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(x, y)=true，则返回 true “a.corresponds(b)(_ < _)位置一一对应”

   val a = Array(1,2,3,4,5)
   val e= Array(1,2,3,4)
   val f = Array(1,2,3,4,5)
   val g = Array(1,2,3,4,8)
   a.corresponds(e)(_==_)//false
   a.corresponds(f)(_==_)//true
   a.corresponds(g)(_==_)//false

count

统计符合条件的元素个数

val a=Array(1,3,5,7,9)
a.count(x=>x>3) //3
a.count(x=>x>5) //2
a.count(x=>if(x<8&& x>3) true else false) //2
//等同于
a.count(x=>(x>3&&x<8))

diff

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

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

distinct

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

  val dis=Array(1,2,3,1,3,8,9)
  dis.distinct// Array[Int] = Array(1, 2, 3, 8, 9)

drop

去掉当前数组前n个元素的

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

dropRight

去掉尾部的 n 个元素

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

dropWhile

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

val a=Array(1,2,3,4)
a.dropWhile(x=>x==2)//返回原数组

endsWith

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

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

exists

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

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

filter

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

val a=Array(1,2,3,4)
a.filter(x=>x>2)//Array(3,4)
a.filterNot(x=>x>2)//Array(1,2) 取反

find

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

val a=Array(1,2,3,4)
val b=a.find(x=>x>5) //None
val b=a.find(x=>x>3) 
b.get //4

flatMap

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

val a=Array(1,2,3,4)
a.flatMap(x=>1 to x)
// Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)
/*
1
1,2
1,2,3
1,2,3,4
*/

flattten

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

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

fold

对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同

val a=Array(1,2,3,4)
a.fold(10)(_+_)
// 20

foldLeft

从左到右计算

val a=Array(1,2,3,4)
a.foldLeft(10)(_+_)
// 20

foldRight

从右到左计算

val a=Array(1,2,3,4)
a.foldRight(10)(_+_)
// 20

forall

判断是不是所有元素都符合条件，返回的是布尔值

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

foreach

遍历元素

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

groupBy

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

val a=Array(1,2,3,4)
a.groupBy(_<3).toList
/* List[(Boolean, Array[Int])] = List((false,Array(3, 4)), 
                                      (true,Array(1, 2)))
                                      */

grouped

按指定数量分组，每组有 size 个元素，返回一个迭代器

val a=Array(1,2,3,4)
a.grouped(3).toList
/*List[Array[Int]] = List(Array(1, 2, 3),
                          Array(4))
                          */

hasDefiniteSize

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

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

head

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

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

headOption

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

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

indexOf(elem)

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

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

indexOf(elem,from)

返回元素 elem 在序列中第一次出现的索引，指定从索引 from 开始查找

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

indexOfSlice(that)

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

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

indexWhere§

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

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

indexWhere(p, from)

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

val a=Array(1,2,3,2,3,4)
a.indexWhere(_>2,4)// 4
a.indexWhere(_>2,0)// 2,下标从0开始

indices

返回当前序列索引集合

val a=Array(1,2,3,2,3,4,5)
val b=a.indices//(0,1,2,3,4,5,6)

init

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

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

inits

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

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

intersect

取两个集合的交集

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

isDefinedAt

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

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

isEmpty

判断序列是否为空

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

isTraversableAgain

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

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

iterator

生成当前序列的迭代器

last

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

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

lastIndexOf(elem)

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

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

lastIndexOf(elem, end)

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

lastIndexOfSlice(that)

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

lastIndexOfSlice(that, end)

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

lastIndexWhere§

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

lastIndexWhere(p, end)

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

lastOption

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

length

返回序列元素个数

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

lengthCompare

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

val a=Array(1,2,3,1,2,3)
a.lengthCompare(10)//-4

map

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

val a = Array(1, 2, 3, 4)
a.map(x => x * 10) // Array(10,20,30,40)
a.map(x=>(x,10))
//Array[(Int, Int)] = Array((1,10), (2,10), (3,10), (2,10), (3,10), (4,10))

max

返回序列中最大的元素

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

maxBy

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

val a=Array(1,2,3,4,5)
a.maxBy(x=>x>3)//4
//如果没有符合条件的，会返回第一个元素

min

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

minBy

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

val a=Array(1,2,3,4,5)
a.mixBy(x=>x>3)//1

mkString

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

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

mkString(sep)

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

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

mkString(start, sep, end)

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

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

nonEmpty

判断序列是否不为空

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

padTo

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

val a=Array(1,2,3,4,5)
a.padTo(10,6)//Array(1,2,3,4,5,6,6,6,6,6,)
a.padTo(3,6)//Array(1,2,3,4,5)

par

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

partition

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

val a=Array(1,2,3,4,5)
a.partition(x => x % 2 == 0)
// (Array[Int], Array[Int]) = (Array(2, 4),Array(1, 3, 5))

patch

def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that

    val a = Array(1, 2, 3, 4)
    val b = Array(7, 8, 9)
    a.patch(1, b, 2)  // Array(1,7,8,9,4)
    a.patch(1, b, 1)  // Array(1,7,8,9,3,4)

permutations

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

    val a = Array(1, 2, 3, 4)
    a.permutations.toList
    //a.permutations 生成的是个迭代器
    /* List[Array[Int]] = List(Array(1, 2, 3, 4), Array(1, 2, 4, 3), 
                               Array(1, 3, 2, 4), Array(1, 3, 4, 2), 
                               Array(1, 4, 2, 3), Array(1, 4, 3, 2), 
                               Array(2, 1, 3, 4), Array(2, 1, 4, 3), 
                               Array(2, 3, 1, 4), Array(2, 3, 4, 1), 
                               Array(2, 4, 1, 3), Array(2, 4, 3, 1), 
                               Array(3, 1, 2, 4), Array(3, 1, 4, 2), 
                               Array(3, 2, 1, 4), Array(3, 2, 4, 1), 
                               Array(3, 4, 1, 2), Array(3, 4, 2, 1), 
                               Array(4, 1, 2, 3), Array(4, 1, 3, 2), 
                               Array(4, 2, 1, 3), Array(4, 2, 3, 1), 
                               Array(4, 3, 1, 2), Array(4, 3, 2, 1))*/

prefixLength

给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
有点类似加了条件的count

product

返回所有元素乘积的值

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

reduce

同 fold，不需要初始值

    val a = Array(1, 2, 3, 4)
    a.reduce(_+_)//10

reduceLeft

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

    val a = Array(1, 2, 3, 4)
    a.reduceLeft(_+_)//10

reduceRight

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

    val a = Array(1, 2, 3, 4)
     a.reduceRight(_+_)//10

reduceLeftOption

同 reduceLeft，返回 Option

    val a = Array(1, 2, 3, 4)
    a.reduceLeftOption(_+_)//Some(10)

reduceRightOption

同 reduceRight，返回 Option

    val a = Array(1, 2, 3, 4)
    a.reduceRightOption(_+_)//Some(10)

reverse

反转序列

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

reverseIterator

生成反向迭代器

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

reverseMap

同 map，方向相反

    val a = Array(1, 2, 3, 4)
    a.reverseMap(_*10)
//Array[Int] = Array(40, 30, 20, 10)

sameElements

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

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

scan

同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果
需要初始值

    val a = Array(1, 2, 3, 4)
    a.scan(0)(_+_)
// Array[Int] = Array(0, 1, 3, 6, 10)

scanLeft

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

    val a = Array(1, 2, 3, 4)
    a.scanLeft(0)(_+_)
// Array[Int] = Array(0, 1, 3, 6, 10)

scanRight

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

    val a = Array(1, 2, 3, 4)
    a.scanRight(0)(_+_)
// Array[Int] = Array(10, 9, 7, 4, 0)

segmentLength

从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个，需要第一个就满足条件，不满足会直接返回0

val a = Array(1, 2, 3, 3, 2, 1, 4,5,6,7)
a.segmentLength(x => x>2, 1)

seq

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

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

size

返回序列元素个数，同 length

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.size//11

slice

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.slice(2,5)//Array(8, 7, 1),2和5是数组下标

sliding(size)

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.sliding(5).toList
/*List[Array[Int]] = List(Array(1, 9, 8, 7, 1), Array(9, 8, 7, 1, 2), 
                          Array(8, 7, 1, 2, 3), Array(7, 1, 2, 3, 6), 
                          Array(1, 2, 3, 6, 7), Array(2, 3, 6, 7, 8), 
                          Array(3, 6, 7, 8, 9))*/

sliding(size, step)

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.sliding(5,4).toList
/*List[Array[Int]] = List(Array(1, 9, 8, 7, 1),
                          Array(1, 2, 3, 6, 7), 
                          Array(7, 8, 9))*/

sortBy/sortWith/sorted

sorted 使用默认的排序规则对序列排序
按指定的排序规则对序列排序
sortWith可以指定排序方式

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.sortBy(x=>x)// 按 x 从小到大，即对原序列升序排列
// Array[Int] = Array(1, 1, 2, 3, 6, 7, 7, 8, 8, 9, 9)
 a.sortBy(x=>0-x)//按 -x 从小到大，即对原序列降序排列
//Array[Int] = Array(9, 9, 8, 8, 7, 7, 6, 3, 2, 1, 1)
 a.sortWith(_>_)
//Array[Int] = Array(9, 9, 8, 8, 7, 7, 6, 3, 2, 1, 1)
a.sorted
//Array[Int] = Array(1, 1, 2, 3, 6, 7, 7, 8, 8, 9, 9)

span

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.span(x => x < 3)
/* (Array[Int], Array[Int]) = (Array(1),Array(9, 8, 7, 1, 2, 3, 6, 7, 8, 9))*/

splitAt

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.splitAt(2)
/* (Array[Int], Array[Int]) = (Array(1, 9),Array(8, 7, 1, 2, 3, 6, 7, 8, 9))*/

startsWith(that)

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
val t=Array(9)
a.startsWith(b)//false

startsWith(that, offset)

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
val t=Array(9)
a.startsWith(t,1)//true

stringPrefix

返回 toString 结果的前缀

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.toString//[I@40ccda8b
a.stringPrefix//[I

subSequence(start,end)

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

val d=Array('a','b','c','d','e','f')
d.subSequence(1,3)// CharSequence = bc
//是char类型

sum

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.sum//61

tail

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.tail//Array(9, 8, 7, 1, 2, 3, 6, 7, 8, 9)

tails

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.tails
/* List[Array[Int]] = List(Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9), 
                           Array(9, 8, 7, 1, 2, 3, 6, 7, 8, 9), 
                           Array(8, 7, 1, 2, 3, 6, 7, 8, 9), 
                           Array(7, 1, 2, 3, 6, 7, 8, 9), 
                           Array(1, 2, 3, 6, 7, 8, 9), 
                           Array(2, 3, 6, 7, 8, 9), 
                           Array(3, 6, 7, 8, 9), 
                           Array(6, 7, 8, 9), 
                           Array(7, 8, 9), 
                           Array(8, 9), A
                           rray(9), 
                           Array())
                                         */

take

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.take(5)//Array[Int] = Array(1, 9, 8, 7, 1)

takeRight

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.takeRight(5)/ Array[Int] = Array(3, 6, 7, 8, 9)

takeWhile

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

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

toArray

将序列转换成 Array 类型

toBuffer

将序列转换成 Buffer 类型

toIndexedSeq

将序列转换成 IndexedSeq 类型

toIterable

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

toIterator

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

toList

将序列转换成 List 类型

toMap

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

val z= Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
z.flatten.map(x=>(x,1)).toMap
//cala.collection.immutable.Map[String,Int] = Map(e -> 1, f -> 1, a -> 1, b -> 1, c -> 1, d -> 1)

toSeq

将序列转换成 Seq 类型

toSet

将序列转换成 Set 类型

toStream

将序列转换成 Stream 类型

toVector

将序列转换成 Vector 类型

transpose

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

val z= Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
z.transpose.toList
//List[Array[String]] = List(Array(a, c, e), Array(b, d, f))

union

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
val b= Array(7, 8, 9)
a.union(b)
// Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9, 7, 8, 9)
b.union(a)
//Array(7, 8, 9, 1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)

unzip

将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组

val z= Array(("a", "b"),("c", "d"),("e", "f"))
z.unzip// (Array[String], Array[String]) = (Array(a, c, e),Array(b, d, f))

unzip3

将含有三个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组

 val z= Array((1,2,3),(4,5,6),(7,8,9))
z.unzip3//  (Array[Int], Array[Int], Array[Int]) = (Array(1, 4, 7),Array(2, 5, 8),Array(3, 6, 9))

update

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

val a =  Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.update(0,10)// a=Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)，更新后不会输出更新后的结果，需要自己查看，更新的是原数组的数据

updated

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

val a =  Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.updated(10,11)// Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 11),更新后会返回结果，但是原数组不变

view

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

val a =  Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.view(0,3).toList//  List[Int] = List(10, 9, 8)，没有toList返回的是个序列，不会输出结果

withFilter

根据条件 p 过滤元素

val a =  Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.withFilter(_<5).map(x=>x)
//Array[Int] = Array(1, 2, 3)

zip

将两个序列对应位置上的元素组成一个元组数组

val b = Array(7,8,9)
val f = Array(4,5,6)
b.zip(f)
// Array((7,4), (8,5), (9,6))
f.zip(b)
//Array((4,7), (5,8), (6,9))

zipAll

def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem

val b = Array(7,8,9,10,11)
val f = Array(4,5,6)
b.zipAll(f,10,66)
//Array[(Int, Int)] = Array((7,4), (8,5), (9,6), (10,66), (11,66))
f.zipAll(b,10,66)
//Array[(Int, Int)] = Array((4,7), (5,8), (6,9), (10,10), (10,11))

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

val b = Array(7,8,9,10,11)
b.zipWithIndex
//Array[(Int, Int)] = Array((7,0), (8,1), (9,2), (10,3), (11,4))