1.Array

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

scala> val arr=Array(1,2,3,4)   // 声明一个数组对象
arr: Array[Int] = Array(1, 2, 3, 4)

scala> val a1=arr(0)            // 读取第一个元素
a1: Int = 1

scala> arr(3)=100                // 替换第四个元素为 100
scala> println(arr.mkString(","))    // 打印数组
1,2,3,100

2.++

合并集合，并返回一个新的数组，新数组包含左右两个集合的内容

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

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

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

3.++:

这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型

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

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

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

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

4.+:

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

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

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

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

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

5.:+

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

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

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

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

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

6./:

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

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

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

7.:\

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

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

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

8.addString(stringbuffer)

def addString(b: StringBuilder): StringBuilder

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

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

scala> val b=new StringBuilder()
b: StringBuilder =

scala> a.addString(b)
res3: StringBuilder = 123

9.addString(stringbuffer, sep)

def addString(b: StringBuilder, sep: String): StringBuilder

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

scala> a.addString(b,",")
res4: StringBuilder = 1231,2,3

10.aggregate

def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B

聚合计算，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
     */
     
    val c = a.par.aggregate(5)(seqno, combine) // 分区
    println("c = " + c)
    /**
     * seq_exp = 5 + 1
     * seq_exp = 5 + 2
     * seq_exp = 5 + 3
     * seq_exp = 5 + 4
     * com_exp = 6 + 7
     * com_exp = 8 + 9
     * com_exp = 13 +17
     * c = 30
     */
  }

通过上面的运算不难发现，不分区时，seqno 是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算。

分区时，seqno 是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法 combine 进行处理。

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

scala> val b=a.aggregate(5)(_+_,_+_)     // 不分区
b: Int = 15

scala> val c=a.par.aggregate(5)(_+_,_+_)    // 分区
c: Int = 30

11.apply

def apply(i: Int): T

获取指定索引处的元素

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

scala> val b=a.apply(1)     // a.apply(i) 同 a(i)
b: Int = 2

scala> a(1)
res5: Int = 2

12.canEqual

def canEqual(that: Any): Boolean

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

//基本上所有对象都可以进行比较
scala> val a=List(1,2)
a: List[Int] = List(1, 2)

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

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

13.charAt

def charAt(index: Int): Char

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

scala> val g=Array('a','b')
g: Array[Char] = Array(a, b)

scala> g.charAt(0)
res26: Char = a

14.clone

def clone(): Array[T]

创建一个副本

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

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

15.collect

def collect[B](pf: PartialFunction[A, B]): Array[B]

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

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

scala> d.collect{case x if x%2==0 => x+1}
res12: Array[Int] = Array(5, 7, 9)

16.collectFirst

def collectFirst[B](pf: PartialFunction[T, B]): Option[B]

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

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

scala> d.collectFirst{case x if x%2==0 => x+1}
res10: Option[Int] = Some(5)

scala> d.collectFirst{case x if x%2==0 => x+1}.get     //4+1
res11: Int = 5

17.combinations

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

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

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

18.contains

def contains[A1 >: A](elem: A1): Boolean

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

scala> val a=List(1,3,5,6)
a: List[Int] = List(1, 3, 5, 6)

scala> a.contains(1)
res19: Boolean = true

19.containsSlice

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

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

scala> val a=List(1,3,5,6)
a: List[Int] = List(1, 3, 5, 6)


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

scala> a.containsSlice(b)
res24: Boolean = true

20.copyToArray(xs)

def copyToArray(xs: Array[A]): Unit

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

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

scala> val b:Array[Int]=new Array(5)
b: Array[Int] = Array(0, 0, 0, 0, 0)

scala> a.copyToArray(b)

scala> b.mkString(",")
res29: String = 1,3,5,0,0

21.copyToArray(xs, start)

def copyToArray(xs: Array[A], start: Int): Unit

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

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

scala> val b:Array[Int]=new Array(5)
b: Array[Int] = Array(0, 0, 0, 0, 0)

scala> a.copyToArray(b,2)

scala> b.mkString(",")
res33: String = 0,0,1,3,5

22.copyToArray(xs, start, len)

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

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

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

scala> val b:Array[Int]=new Array(5)
b: Array[Int] = Array(0, 0, 0, 0, 0)

scala> a.copyToArray(b,2,2)

scala> b.mkString(",")
res35: String = 0,0,1,3,0

23.copyToBuffer

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

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

scala> import scala.collection.mutable.ListBuffer    //导入相关的包
import scala.collection.mutable.ListBuffer

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

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

scala> a.copyToBuffer(b)

scala> b.mkString(",")
res38: String = 1,3,5

24.corresponds

def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean

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

//下面代码检查 a 和 b 长度是否相等，并且 a 中元素是否小于 b 中对应位置的元素
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

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

scala> a.corresponds(b)(_<_)    //判断a与b长度相同，且对应元素小于b
res42: Boolean = true

25.count

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

统计符合条件的元素个数

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

scala> a.count(x => x>=3)
res43: Int = 3

26.diff

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

计算当前数组与另一个数组的差集，数组于另一个数组的差集，去掉于其他数组的交集，左边为准

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

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

scala> a.diff(b)
res45: List[Int] = List(1, 2, 3)

27.distinct

def distinct: Array[T]

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

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

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

28.drop

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

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

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

scala> val b=a.drop(2)
b: List[Int] = List(2, 3, 4, 5, 5)

29.dropRight

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

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

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

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

30.dropWhile

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

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

//下面去除数组 a 中大于 2 的元素，第一个元素 3 满足，它后面的元素 1 不满足，所以返回 (1,2,3,4)
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

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

31.endsWith

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

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

scala> val a=List(23,23,56,2,3)
a: List[Int] = List(23, 23, 56, 2, 3)

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

scala> a.endsWith(b)
res46: Boolean = true

32.exists

def exists(p: (T) ⇒ Boolean): Boolean

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

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

scala> a.exists(x => x==3)
res47: Boolean = true

33.filter

def exists(p: (T) ⇒ Boolean): Boolean

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

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

scala> val b=a.filter(x => x>2)
b: List[Int] = List(3, 4)

34.find

def find(p: (T) ⇒ Boolean): Option[T]

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

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

scala> val b=a.find(x =>x>2)
b: Option[Int] = Some(3)

35.flatMap

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]

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

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

scala> val b=a.flatMap(x => 1 to x)
b: Array[Int] = Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)
    /**
     * 1,1,2,1,2,3,1,2,3,4
     * 从 1 开始，分别对集合 a 中的每个元素生成一个递增序列，过程如下
     * 1
     * 1,2
     * 1,2,3
     * 1,2,3,4
     */

36.flatten

def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]

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

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

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

37.fold

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1ClassTag[U]): Array[U]

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

  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.fold(5)(seqno) // 不分区
    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.fold(5)(seqno) // 分区
    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
     */
  }

38.foldLeft

def foldLeft[B](z: B)(op: (B, T) ⇒ B): BClassTag[U]): Array[U]

从左到右计算，简写方式：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
     */
  }

39.foldRight

foldRight[B](z: B)(op: (B, T) ⇒ B): B

从右到左计算，简写方式：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
     */
  }

40.forall

def forall(p: (T) ⇒ Boolean): Boolean

检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true

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

scala> a.forall(x =>x>0)
res49: Boolean = true

scala> a.forall(x =>x>1)
res50: Boolean = false

41.foreach

def foreach(f: (A) ⇒ Unit): Unit

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

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

scala> a.foreach(x =>println(x))
1
2
3
4

42.groupBy

def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]

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

//把数组中小于 3 的元素分到一组，其他元素的分到另一组，返回 Map[String, Array[Int]]
scala> val a=List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala>   val b = a.groupBy(x => x match {
     |       case x if (x < 3) => "small"
     |       case _ => "big"
     |     })
b: scala.collection.immutable.Map[String,List[Int]] = Map(small -> List(1, 2), big -> List(3, 4))

scala> b.foreach(println)
(small,List(1, 2))
(big,List(3, 4))

43.grouped

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

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

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

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

44.hasDefiniteSize

def hasDefiniteSize: Boolean

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

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

scala> a.hasDefiniteSize
res56: Boolean = true

45.head

def head: T

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

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

scala> a.head
res57: Int = 1

46.headOption

def headOption: Option[T]

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

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

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

47.indexOf(elem)

def indexOf(elem: T): Int

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

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

scala> a.indexOf(3)
res59: Int = 2

scala> a.indexOf(5)
res60: Int = 4


scala> val c=List(2,4,6,7,8)
c: List[Int] = List(2, 4, 6, 7, 8)

scala> c.indexOf(5)
res61: Int = -1

scala> c.indexOf(6)
res62: Int = 2

scala> c.indexOf(8)
res63: Int = 4

48.indexOf(elem, from)

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

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

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

scala> a.indexOf(3,2)
res64: Int = 2

scala> a.indexOf(3,4)
res65: Int = 5

49.indexOfSlice(that)

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

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

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

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

scala> a.indexOfSlice(b)
res66: Int = 1

50.indexOfSlice(that, from)

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

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

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

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

scala> a.indexOfSlice(b,2)
res67: Int = 5

scala> a.indexOfSlice(b,6)
res69: Int = 9

51.indexWhere§

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

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

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


scala> a.indexWhere(x => x>5)
res71: Int = 3           //第一个值下标为3

52.indexWhere(p, from)

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

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

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

scala> a.indexWhere(x => x>4,3)
res74: Int = 3

53.indices

def indices: collection.immutable.Range

返回当前序列索引集合

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

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

54.init

def init: Array[T]

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

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

scala> val b=a.init
b: Array[Int] = Array(2, 4, 5, 7)

55.inits

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

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

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

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

56.intersect

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

取两个集合的交集

scala> var a=List(2,3,4,5,6)
a: List[Int] = List(2, 3, 4, 5, 6)

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

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

57.isDefinedAt

def isDefinedAt(idx: Int): Boolean

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

scala> var a=List(2,3,4,5,6)
a: List[Int] = List(2, 3, 4, 5, 6)

scala> a.isDefinedAt(3)
res75: Boolean = true

scala> a.isDefinedAt(5)
res76: Boolean = false

58.isEmpty

def isEmpty: Boolean

判断序列是否为空

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

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

scala> a.isEmpty
res77: Boolean = false

scala> b.isEmpty
res78: Boolean = true

59.isTraversableAgain

def isTraversableAgain: Boolean

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

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

scala> val b=a.iterator
b: Iterator[Int] = non-empty iterator

scala> a.isTraversableAgain
res79: Boolean = true

scala> b.isTraversableAgain
res80: Boolean = false

60.iterator

def iterator: collection.Iterator[T]

生成当前序列的迭代器

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

scala> val b=a.iterator
b: Iterator[Int] = non-empty iterator

scala> b.mkString(",")
res81: String = 1,2,3,4

61.last

def last: T

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

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

scala> a.last
res82: Int = 4

62.lastIndexOf(elem)

def lastIndexOf(elem: T): Int

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

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

scala> a.lastIndexOf(3)
res84: Int = 5

scala> a.lastIndexOf(4)
res85: Int = 4

63.lastIndexOf(elem, end)

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

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

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

scala> a.lastIndexOf(2,3)
res86: Int = 2

64.lastIndexOfSlice(that)

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

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

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

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

scala> a.lastIndexOfSlice(b)
res87: Int = 4

65.lastIndexOfSlice(that, end)

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

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

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

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

scala> a.lastIndexOfSlice(b,3)
res88: Int = 2

66.lastIndexWhere§

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

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

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

scala> a.lastIndexWhere(x => x>3)
res90: Int = 6

67.lastIndexWhere(p, end)

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

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

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

scala> a.lastIndexWhere(x => x>3,5)
res91: Int = -1

scala> a.lastIndexWhere(x => x>3,6)
res92: Int = 6

68.lastOption

def lastOption: Option[T]

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

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

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

69.length

def length: Int

返回序列元素个数

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

scala> a.length
res94: Int = 7

70.lengthCompare

def lengthCompare(len: Int): Int

比较序列的长度和参数 len(下标，最前面的一个)，返回序列的长度 - len

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

scala> a.lengthCompare(2)
res95: Int = 5

scala> a.lengthCompare(1)
res96: Int = 6

scala> a.lengthCompare(0)
res97: Int = 7

71.map

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

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

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

scala> a.map(x => x*10)
res98: List[Int] = List(10, 20, 30)

scala> a.map(_*10)
res99: List[Int] = List(10, 20, 30)

72.max

def max: A

返回序列中最大的元素

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

scala> a.max
res100: Int = 3

73.maxBy§

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

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

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

scala> a.maxBy(_>2)
res101: Int = 3

74.min

def max: A

返回序列中最小的元素

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

scala> a.min
res102: Int = 1

75.minBy§

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

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

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

scala> a.minBy(_>2)
res103: Int = 1

76.mkString

def mkString: String

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

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

scala> a.mkString
res105: String = 123

77.mkString(sep)

def mkString: String

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

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

scala> a.mkString(",")
res106: String = 1,2,3

78.mkString(start, sep, end)

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

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

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

scala> a.mkString("(",",",")")
res108: String = (1,2,3)

scala> a.mkString("(","*",")")
res110: String = (1*2*3)

79.nonEmpty

def nonEmpty: Boolean

判断序列是否不为空

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

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

scala> a.nonEmpty
res111: Boolean = true

scala> b.nonEmpty
res112: Boolean = false

80.padTo(len,elem)

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

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

scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
//填充一个长度为 7 的序列，不足位补 8
scala> val b=a.padTo(7,8)
b: Array[Int] = Array(1, 2, 3, 4, 8, 8, 8)

81.par

def par: ParArray[T]

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

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

scala> val b=a.par
b: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4)

82.partition

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

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

scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
//以序列元素是否是偶数来拆分
scala> val b=a.partition(_%2==0)
b: (Array[Int], Array[Int]) = (Array(2, 4),Array(1, 3))

83.patch

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

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

//从 a 的第二个元素开始，取两个元素，即 2 和 3 ，将这两个元素替换为序列 b
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

scala> val b=Array(6,7,8)
b: Array[Int] = Array(6, 7, 8)

scala> a.patch(1,b,2)
res113: Array[Int] = Array(1, 6, 7, 8, 4)

84.permutations

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

permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 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))

85.prefixLength

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

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

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

scala> a.prefixLength(_<6)
res114: Int = 5

86.product

def product: A

返回所有元素乘积的值

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

scala> a.product
res115: Int = 24             // 1*2*3*4=24            

87.reduce

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

同 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

88.reduceLeft

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

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

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

89.reduceRight

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

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

scala> val b=a.reduceRight(seqno)
seq_exp =3 + 4
seq_exp =2 + 7
seq_exp =1 + 9
b: Int = 10

90.reduceLeftOption

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

同 reduceLeft，返回 Option

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

91.reduceRightOption

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

同 reduceRight，返回 Option

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

92.reverse

def reverse: Array[T]

反转序列

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

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

93.reverseIterator

def reverseIterator: collection.Iterator[T]

生成反向迭代器

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

scala> val b=a.reverseIterator
b: Iterator[Int] = non-empty iterator

scala> b.foreach(println)
4
3
2
1

94.reverseMap

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

同 map，方向相反

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

scala> val b=a.reverseMap(_*10)
b: Array[Int] = Array(40, 30, 20, 10)

95.sameElements

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

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

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

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

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

scala> a.sameElements(b)
res2: Boolean = true

scala> a.sameElements(c)
res3: Boolean = false

96.scan

def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That

同 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)      //(((5+1)+2)+3)+4

97.scanLeft

def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

同 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)

98.scanRight

def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

同 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)      //(((5+4)+3)+2)+1

99.segmentLength

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

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

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

scala> a.segmentLength(_>3,3)
res4: Int = 1

100.seq

def seq: collection.mutable.IndexedSeq[T]

产生一个引用当前序列的 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)

101.size

def size: Int

返回序列元素个数，同 length

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

scala> a.size
res5: Int = 4

102.slice

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

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

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

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

103.sliding(size)

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

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

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

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

104.sliding(size, step)

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

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

//第一组从 1 开始， 第二组从 3 开始，因为步长是 2
scala> val a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)

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

105.sortBy

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

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

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

scala> val b=a.sortBy(x => x)     // 按 x 从小到大，即对原序列升序排列
b: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val c=a.sortBy(x =>0 - x)     // 按 -x 从小到大，即对原序列降序排列
c: Array[Int] = Array(5, 4, 3, 2, 1)

106.sorted

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

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

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

scala> val b=a.sorted       // 默认升序排列
b: Array[Int] = Array(1, 2, 3, 4, 5)

107.span

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

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

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

scala> val b=a.span(x => x<3)
b: (Array[Int], Array[Int]) = (Array(1, 2),Array(3, 4, 5))

108.splitAt

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

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

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

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

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

109.startsWith(that)

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

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

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

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

scala> a.startsWith(b)
res6: Boolean = true

110.startsWith(that, offset)

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

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

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

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

scala> a.startsWith(b,1)
res7: Boolean = true

111.stringPrefix

def stringPrefix: String

返回 toString 结果的前缀

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

scala> a.toString()
res8: String = [I@3c554dd5

scala> a.stringPrefix
res10: String = [I

112.subSequence

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

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

scala> val a=Array('a','b','c','d','e')
a: Array[Char] = Array(a, b, c, d, e)

scala> val b=a.subSequence(2,4)
b: CharSequence = cd

113.sum

def sum: A

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

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

scala> a.sum
res11: Int = 15

114.tail

def tail: Array[T]

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

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


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

115.tails

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

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

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


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

116.take

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

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

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

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

117.takeRight

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

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

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

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

118.takeWhile

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

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

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

scala> val b=a.takeWhile(x => x <4)
b: Array[Int] = Array(1, 2, 3)

119.toArray

def toArray: Array[A]

将序列转换成 Array 类型

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

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

120.toBuffer

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

将序列转换成 Buffer 类型

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

scala> a.toBuffer
res15: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4)

121.toIndexedSeq

def toIndexedSeq: collection.immutable.IndexedSeq[T]

将序列转换成 IndexedSeq 类型

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

scala> a.toIndexedSeq
res14: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4)

122.toIterable

def toIterable: collection.Iterable[T]

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

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

scala> a.toIterable
res17: Iterable[Int] = List(1, 2, 3, 4)

123.toIterator

def toIterator: collection.Iterator[T]

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

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

scala> a.toIterator
res18: Iterator[Int] = non-empty iterator

124.toList

def toList: List[T]

将序列转换成 List 类型

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

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

125.toMap

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

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

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

scala> a.map((_,1)).toMap
res6: scala.collection.immutable.Map[Int,Int] = Map(1 -> 1, 2 -> 1, 3 -> 1, 4 -> 1)

126.toSeq

def toSeq: collection.Seq[T]

将序列转换成 Seq 类型

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

scala> a.toSeq
res7: Seq[Int] = WrappedArray(1, 2, 3, 4)

127.toSet

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

将序列转换成 Set 类型

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

scala> a.toSet
res8: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

128.toStream

def toStream: collection.immutable.Stream[T]

将序列转换成 Stream 类型

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

scala> a.toStream
res9: scala.collection.immutable.Stream[Int] = Stream(1, ?)

129.toVector

def toVector: Vector[T]

将序列转换成 Vector 类型

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

scala> a.toVector
res11: Vector[Int] = Vector(1, 2, 3, 4)

130.transpose

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

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

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))

131.union

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

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

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

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

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

132.unzip

def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])

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

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))

133.unzip3

def unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])

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

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))

134.update

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

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

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

scala> a.update(2,8)

scala> a.mkString(",")
res2: String = 1,2,8,4,5

135.updated

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

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

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

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

136.view

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

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

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

scala> val b=a.view(1,4)
b: scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(...)

scala> b.mkString(",")
res3: String = 2,3,4

137.withFilter

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

根据条件 p 过滤元素

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

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

138.zip

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

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

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))

139.zipAll

def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]

同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem

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

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

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

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

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

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

140.zipWithIndex

def zipWithIndex: Array[(A, Int)]

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

scala> val a=Array('a','b','c','d')
a: Array[Char] = Array(a, b, c, d)

scala> val b=a.zipWithIndex
b: Array[(Char, Int)] = Array((a,0), (b,1), (c,2), (d,3))