Scala数组函数

1、++

方法：def ++[B](that: GenTraversableOnce[B]): Array[B]
说明：合并集合，不去重，并且返回一个新数组
代码举例：

注：因为数组中包含数字也包含字符串，所以会用Any顶级类型接收

2、++：

方法：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
说明：合并集合，冒号右边的集合类型决定返回新数组的类型
代码举例：

3、+：

方法：def +:(elem: A): Array[A]
说明：在集合前面加一个数，并返回新的数组
代码举例：

4、:+

方法：def +:(elem: A): Array[A]
说明：在集合后面加一个数，并返回新的数组
代码举例：

5、/:

方法：def /:[B](z: B)(op: (B, T) ⇒ B): B
说明：对数组中所有的元素进行相同的操作,左子树foldLeft的简写
代码举例：

6、:\

方法：def /:[B](z: B)(op: (T，B) ⇒ B): B
说明：对数组中所有的元素进行相同的操作,右子树foldRight的简写
代码举例：

7、addString

7.1

方法：def addString(b: StringBuilder): StringBuilder
说明：将数组中的元素逐个添加到b中
代码举例：

7.2

方法：def addString(b: StringBuilder, sep: String): StringBuilder
说明：将数组中的元素逐个添加到b中，每个元素用sep分隔符分开
代码举例：

7.3

方法：def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
说明：将数组中的元素逐个添加到b中，在首尾各加一个字符串，并指定sep分隔符
代码举例：

8、aggregate

方法：def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
说明：聚合函数,aggregate是柯里化方法,参数是两个方法;将aggregate的两个参数分别封装成两个方法，并把计算过程打印出来
代码举例：

9、andThen

方法：
说明：
代码举例：

10、apply

方法：def apply(i: Int): T
说明：取出索引处的元素
代码举例：

11、applyOrElse

方法：
说明：
代码举例：

12、array

方法：
说明：显示数组地址
代码举例：

13、canEqual

方法：def canEqual(that: Any): Boolean
说明：判断两个对象是否可以进行比较，基本上都是true,因为对象基本上都可以比较
代码举例：

14、charAt

方法：def charAt(index: Int): Char
说明：获取index索引处的字符，这个方法会执行一个隐式的转换。将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生
代码举例：

15、clone

方法：def clone(): Array[T]
说明：创建一个副本，浅拷贝：复制的是地址的引用
代码举例：

16、collect

方法：def collect[B](pf: PartialFunction[A, B]): Array[B]
说明：并行计算(偏函数),得到一个新的数组对象，参数为偏函数
代码举例：

17、collectFirst

方法：def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
说明：在序列中查找第一次符合偏函数定义的元素，执行偏函数计算
代码举例：

18、combinations

方法：def combinations(n: Int): collection.Iterator[Array[T]]
说明：排列组合，选出所有包含字符不一样的组合,包含字符数为n个
代码举例：

19、companion

20、compose

21、contains

方法：def contains[A1 >: A](elem: A1): Boolean
说明：序列中是否包含指定对象
代码举例：

22、containsSlice

方法：def containsSlice[B](that: GenSeq[B]): Boolean
说明：判断当前序列中是否包含另一个序列,并且序列中元素次序要求一致
代码举例：

23、copyToArray

23.1

方法：def copyToArray(xs: Array[A]): Unit
说明：拷贝到一个新数组中,如果新数组长度多长，0补齐
代码举例：

23.2

方法：copyToArray(xs: Array[A], start: Int, len: Int): Unit
说明：拷贝到一个新数组中,如果新数组长度多长，0补齐；将拷贝的数据放置xs数组的start索引位置,拷贝len个数据
代码举例：

24、copyToBuffer

方法：def copyToBuffer[B >: A](dest: Buffer[B]): Unit
说明：将数据中的内容拷贝到ArrayBuffer中
代码举例：

25、coresponds

方法：def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
说明：判断两个序列长度以及对应位置元素是否符合某个条件，如果两个序列具有相同的元素数量并且p(x,y)=true,返回true
代码举例：

26、count

方法：count(p: (T) ⇒ Boolean): Int
说明：统计符合条件的元素个数
代码举例：

27、deep

方法：
说明：返回IndexedSeq的类型的数组
代码举例：

28、diff

方法：def diff(that: collection.Seq[T]): Array[T]
说明：计算当前数组与另一数组的不同，将当前数组中没有再另一个数组中出现的元素返回，形成一个新数组
代码举例：

29、distinct

方法：def distinct: Array[T]
说明：去除当前集合中重复的元素，只保留一个
代码举例：

30、drop

方法：def drop(n: Int): Array[T]
说明：将当前序列中的前n个元素去除，返回一个新序列
代码举例：

31、dropRight

方法：def dropRight(n: Int): Array[T]
说明：去除当前序列中的后n个元素，并返回一个新序列返回
代码举例：

32、dropWhile

方法：def dropWhile(p: (T) ⇒ Boolean): Array[T]
说明：去除当前数组中符合条件的元素，从当前数组的第一个元素就要满足条件，如不满足，直接返回原数组
代码举例：

33、elemManifest

34、elemTag

35、endsWith

方法：def endsWith[B](that: GenSeq[B]): Boolean
说明：判断是一个序列否以某个序列结尾
代码举例：

36、exists

方法：def exists(p: (T) ⇒ Boolean): Boolean
说明：判断当前数组是否包含符合条件的元素
代码举例：

37、filter

方法：def filter(p: (T) ⇒ Boolean): Array[T]
说明：取出当前数组中符合条件的元素，组成新的数组返回
代码举例：

38、filterNot

方法：def filterNot(p: (T) ⇒ Boolean): Array[T]
说明：与filter相反,取出当前数组中不符合条件的元素，组成新的数组返回
代码举例：

39、find

方法：def find(p: (T) ⇒ Boolean): Option[T]
说明：查找第一个符合条件的元素
代码举例：

40、flatMap

方法：def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
说明：先对当前序列的每一个元素进行操作，然后再降维，结果放入新序列返回
代码举例：

41、flatten

方法：def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
说明：降维，将二维数组的所有元素联合一起，形成一个一维数组
代码举例：

42、fold

方法：def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
说明：对序列中的每个元素进行二元运算，和aggregate有类似的语义
代码举例：

43、foldLeft

方法：def foldLeft[B](z: B)(op: (B, T) ⇒ B): B
说明：左子树，从左到右计算，用法与/:相似
代码举例：

43、foldRight

方法：def foldRight[B](z: B)(op: (B, T) ⇒ B): B
说明：右子树，从右到左计算，用法与:\相似
代码举例：

44、forall

方法：def forall(p: (T) ⇒ Boolean): Boolean
说明：检测序列中的元素是否都满足条件P，如果序列为空，返回true
代码举例：

45、foreach

方法：def foreach(f: (A) ⇒ Unit): Unit
说明：遍历序列中的元素，进行f操作
代码举例：

46、genericBuilder

47、groupBy

方法：def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
说明：按条件分组，条件由f匹配,返回值是Map类型,每个key对应一个序列
代码举例：

48、grouped

方法：def grouped(size: Int): collection.Iterator[Array[T]]
说明：按指定数量分组，每组有size个元素,返回一个集合
代码举例：

49、hasDefiniteSize

方法：def hasDefiniteSize: Boolean
说明：检测序列是否存在有限的长度
代码举例：

50、head

方法：def head: T
说明：返回序列的第一个元素,如果序列为空，引发错误
代码举例：

51、headOption

方法：def headOption: Option[T]
说明：返回Option类对象,就是scala.Some或者None,如果序列为空,必须给数组一个泛型，返回None
代码举例：

52、indexOf

52.1

方法：def indexOf(elem: T): Int
说明：返回指定元素在序列中的索引,找到第一个就返回
代码举例：

52.2

方法：def indexOf(elem: T, from: Int): Int
说明：返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回
代码举例：

53、indexOfSlice

53.1

方法：def indexOfSlice[B >: A](that: GenSeq[B]): Int
说明：检测当前序列知否包含另一个序列，并返回第一个匹配出现的序列的索引
代码举例：

53.2

方法：def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
说明：检测当前序列中是否包含另一个序列(that),并返回第一个匹配出现的序列的索引，指定从 from 索引处开始
代码举例：

54、indexWhere

54.1

方法：def indexWhere(p: (T) ⇒ Boolean): Int
说明：返回当前序列中第一个满足条件的元素的索引
代码举例：

54.2

方法：def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
说明：返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始
代码举例：

55、indices

方法：def indices: collection.immutable.Range
说明：返回当前序列索引集合
代码举例：

56、init

方法：def init: Array[T]
说明：返回当前序列中不包含最后一个元素的序列
代码举例：

57、inits

方法：def inits: collection.Iterator[Array[T]]
说明：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象
代码举例：

58、intersect

方法：def intersect(that: collection.Seq[T]): Array[T]
说明：取两个集合的交集，返回一个新数组
代码举例：

59、isDefinedAt

方法：def isDefinedAt(idx: Int): Boolean
说明：判断序列中是否存在指定索引
代码举例：

60、isEmpty

方法：def isEmpty: Boolean
说明：判断当前序列是否为空
代码举例：

61、isTraversableAgain

方法：def isTraversableAgain: Boolean
说明：判断序列是否可以反复遍历,对于 Traversables 一般返回true，对于 Iterators 返回 false
代码举例：

62、iterator

方法：def iterator: collection.Iterator[T]
说明：对序列中的每一个元素产生一个iterator
代码举例：

63、last

方法：def last: T
说明：取得序列中的最后一个元素
代码举例：

64、lastIndexOf

64.1

方法：def lastIndexOf(elem: T): Int
说明：取得序列中最后一个等于elem元素的位置
代码举例：

64.2

方法：def lastIndexOf(elem: T, end: Int): Int
说明：取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前（包括）的元素中查找
代码举例：

65、lastIndexOfSlice

65.1

方法：def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
说明：判断当前序列中是否包含序列that,并且返回最后一次出现该序列的位置的索引
代码举例：

65.2

方法：def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
说明：判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，指定在 end 之前（包括）的元素中查找
代码举例：

66、lastIndexWhere

66.1

方法：def lastIndexWhere(p: (T) ⇒ Boolean): Int
说明：返回当前序列中最后一个满足条件的元素索引
代码举例：

66.2

方法：def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
说明：返回当前序列中最后一个满足条件 p 的元素的索引，指定在 end 之前（包括）的元素中查找
代码举例：

67、length

方法：def length: Int
说明：返回当前序列中的元素个数
代码举例：

68、lengthCompare

方法：def lengthCompare(len: Int): Int
说明：比较序列的长度和参数len，根据两者关系返回不同的值。比较规则：数组的长度-给定的值
代码举例：

69、lift

70、map

方法：def map[B](f: (A) ⇒ B): Array[B]
说明：对序列中的元素进行f操作，相当于java中的foreach
代码举例：

71、max

方法：def max: A
说明：返回序列中最大的元素
代码举例：

72、maxBy

方法：def minBy[B](f: (A) ⇒ B): A
说明：返回序列中的第一个符合条件的元素
代码举例：

73、min

方法：def min: A
说明：返回序列中最小的元素
代码举例：

74、minBy

方法：def minBy[B](f: (A) ⇒ B): A
说明：返回序列中的第一个不符合条件的元素
代码举例：

75、mkString

75.1

方法：def mkString: String
说明：将所有元素组合成一个字符串
代码举例：

75.2

方法：def mkString(sep: String): String
说明：将所有元素组合成一个字符串，以 sep 作为元素间的分隔符
代码举例：

75.3

方法：def mkString(start: String, sep: String, end: String): String
说明：将所有元素组合成一个字符串以start开头，sep作为元素分隔符，end结尾
代码举例：

76、nonEmpty

方法：def nonEmpty: Boolean
说明：判断序列不是空
代码举例：

77、orElse

78、padTo

方法：def padTo(len: Int, elem: A): Array[A]
说明：后补齐,如果当前序列长度小于 len,那么新产生的序列长度是 length。多出的几个位置填充 elem，如果当前序列大于等于 len ，则返回当前序列
代码举例：

79、par

方法：def par: ParArray[T]
说明：返回一个并行实现，产生的并行序列，不能被修改
代码举例：

80、partition

方法：def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
说明：按条件将序列拆分为两个新数组，满足条件的放到第一个序列中，其余放到第二个序列
代码举例：

81、patch

方法：def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
说明：批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that
代码举例：

82、permutations

方法：def permutations: collection.Iterator[Array[T]]
说明：排列组合，与combinations不同的是，组合中的内容可以相同，但是顺序不能相同
代码举例：

83、prefixLength

方法：def prefixLength(p: (T) ⇒ Boolean): Int
说明：给定一个条件，返回一个前置数列的长度，这个数列中的元素都满足，要求从第一个元素开始，一旦不符合，返回0
代码举例：

84、product

方法：def product: A
说明：返回所有元素乘积的值
代码举例：

85、reduce

方法：def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
说明：同fold,不需要初始值
代码举例：

86、reduceLeft

方法：def reduceLeft[B >: A](op: (B, T) ⇒ B): B
说明：从左向右计算
代码举例：

87、redueceLeftOption

方法：def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
说明：如果数组为空，返回None
代码举例：

88、reduceOption

89、reduceRight

方法：def reduceRight[B >: A](op: (T, B) ⇒ B): B
说明：从右向左计算
代码举例：

90、reduceRightOption

方法：def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
说明：如果数组为空，返回None
代码举例：

91、repr

92、reverse

方法：def reverse: Array[T]
说明：反转序列
代码举例：

93、reverseIterator

方法：def reverseIterator: collection.Iterator[T]
说明：反向生成迭代
代码举例：

94、reverseMap

方法：def reverseMap[B](f: (A) ⇒ B): Array[B]
说明：同 map 方向相反
代码举例：

95、runWith

96、sameElements

方法：def sameElements(that: GenIterable[A]): Boolean
说明：判断两个序列是否顺序和对应位置上的元素都一样
代码举例：

97、scan

方法：def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf:CanBuildFrom[Array[T], B, That]): That
说明：用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回
代码举例：

98、scanLeft

方法：def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
说明：从左向右计算
代码举例：

99、scanRight

方法：def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
说明：从右向左计算
代码举例：

100、segmentLength

方法：def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
说明：从序列的 from 处开始向后查找，所有满足条件的连续元素的长度，一旦有不符合条件的元素，后面再有符合条件的元素也无关
代码举例：

101、seq

方法：def seq: collection.mutable.IndexedSeq[T]
说明：产生一个引用当前序列的 sequential 视图，将数组转换为seq集合
代码举例：

3# 102、size
方法：def size: Int
说明：返回序列元素个数，同 length
代码举例：

103、slice

方法：def slice(from: Int, until: Int): Array[T]
说明：取出当前序列中，from 到 until 之间的片段
代码举例：

104、sliding

104.1

方法：def sliding(size: Int): collection.Iterator[Array[T]]
说明：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
代码举例：

104.2

方法：def sliding(size: Int, step: Int): collection.Iterator[Array[T]]
说明：设置步进 step，第一个元素组合完后，下一个从上一个元素位置+step后的位置处的元素开始
代码举例：

105、sortBy

方法：def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
说明：按指定的排序规则排序
代码举例：

106、sortWith

方法：def sortWith(lt: (T, T) ⇒ Boolean): Array[T]
说明：自定义排序方法 lt
代码举例：

107、sorted

方法：def sorted、[B >: A](implicit ord: math.Ordering[B]): Array[T]
说明：使用默认的排序规则对序列排序
代码举例：

108、span

方法：def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
说明：分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止,之前的元素放到第一个集合，其它的放到第二个集合
代码举例：

109、splitAt

方法：def splitAt(n: Int): (Array[T], Array[T])
说明：从指定位置开始，把序列拆分成两个集合，指定位置上的元素包含在后一个集合中
代码举例：

110、startsWith

方法：def startsWith[B](that: GenSeq[B], offset: Int): Boolean
说明：从指定偏移处，是否以某个序列开始
代码举例：

111、stringPrefix

方法：def stringPrefix: String
说明：返回 toString 结果的前缀
代码举例：

112、subSequence

方法：def subSequence(start: Int, end: Int): CharSequence
说明：返回 start 和 end 间的字符序列，左闭右开
代码举例：

113、sum

方法：def sum: A
说明：序列求和，元素需为Numeric[T]类型
代码举例：

114、tail

方法：def tail: Array[T]
说明：返回除了当前序列第一个元素的其它元素组成的序列
代码举例：

115、tails

方法：def tails: collection.Iterator[Array[T]]
说明：同inits方法
代码举例：

116、take

方法：def take(n: Int): Array[T]
说明：返回当前序列中前 n 个元素组成的序列
代码举例：

117、takeRight

方法：def takeRight(n: Int): Array[T]
说明：返回当前序列中，从右边开始，选择 n 个元素组成的序列
代码举例：

118、takeWhile

方法：def takeWhile(p: (T) ⇒ Boolean): Array[T]
说明：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列，如果第一个元素的就不满足，直接返回空数组
代码举例：

119、toArray

方法：def toArray: Array[A]
说明：转换成 Array12 1类型
代码举例：

120、toBuffer

方法：def toBuffer[A1 >: A]: Buffer[A1]
说明：转换成 Buffer 类型，可变长集合
代码举例：

121、toIndexedSeq

方法：def toIndexedSeq: collection.immutable.IndexedSeq[T]
说明：转换成 IndexedSeq 类型
代码举例：

122、toIterator

方法：def toIterator: collection.Iterator[T]
说明：转换成可迭代的类型；
代码举例：

123、toIterable

方法：def toIterable: collection.Iterable[T]
说明：转换成可迭代的类型
代码举例：

124、toList

方法：def toList: List[T]
说明：同 List 类型，固定长集合
代码举例：

125、toMap

方法：def toMap[T, U]: Map[T, U]
说明：同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据
代码举例：

126、toSeq

方法：def toSeq: collection.Seq[T]
说明：同 Seq 类型
代码举例：

127、toStream

方法：def toStream: collection.immutable.Stream[T]
说明：同 Stream 类型
代码举例：

128、toTraversable

129、toVector

方法：def toVector: Vector[T]
说明：同 Vector 类型
代码举例：

130、transform

131、transpose

方法：def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
说明：矩阵转换，二维数组行列转换
代码举例：

132、union

方法：def union(that: collection.Seq[T]): Array[T]
说明：联合两个序列，同操作符 ++，不去重
代码举例：

133、unzip

方法：def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
说明：将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列
代码举例：

134、unzip3

方法：def unzip3[T1, T2, T3](implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2:5 ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
说明：将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列
代码举例：

135、update

方法：def update(i: Int, x: T): Unit
说明：将序列中 i 索引处的元素更新为 x
代码举例：

136、updated

方法：def updated(index: Int, elem: A): Array[A]
说明：将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
代码举例：

137、view

方法：def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
说明：返回 from 到 until 间的序列，不包括 until 处的元素
代码举例：

138、withFilter

方法：def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
说明：根据条件 p 过滤元素，返回符合要求的序列
代码举例：

139、zip

方法：def zip[B](that: GenIterable[B]): Array[(A, B)]
说明：将两个序列对应位置上的元素组成一个pair序列
代码举例：

140、zipAll

方法：def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
说明：同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem
代码举例：

141、zipWithIndex

方法：def zipWithIndex: Array[(A, Int)]
说明：序列中的每个元素和它的索引组成一个序列
代码举例：