scala数组、集合函数大全
一、查看scala所有数组、集合函数
查看方法：
- 在 window DOS 窗口，输入 scala 进入scala命令行
- 随意定义一个数组：
val arr = Array(1,2,3,4) - 输入：
arr.+ Tab 键即可显示scala所有数组、集合函数，如下图所示：
二、sacla数组、集合函数实例解析
方法名： ++
描述： 合并两个序列(同类型的数组或集合,若不同类型以左边数组或集合为准)
返回值： 数组或集合
示例：
val a = Array(1,2,3)
val b = Array(4,5,6)
val c = List(7,8,9)
val d = a ++ b
val d = a ++ c
val d = c ++ a
如下图：
方法名： ++:
描述： 合并两个序列(同类型的数组或集合,若不同类型以右边数组或集合为准)
返回值： 数组或集合
示例：
val a = Array(1,2,3)
val b = Array(4,5,6)
val c = List(7,8,9)
val d = a ++: b
val d = a ++: c
val d = c ++: a
如下图：
方法名： +:
描述： 在数组前面添加一个元素(添加的元素在前，就在数组 头部 添加，冒号要离数组近)
返回值： 数组
示例：
val a = Array(1,2,3)
val b = 1 +: a
如下图：
方法名： /:
描述： 对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写(冒号要离数组近)
返回值： 计算结果
示例：
val a = List(1, 2, 3, 4)
val b = (10 /: a) (_ + _) // (((10+1)+2)+3)+4
val c = (10 /: a) (_ * _) // (((10*1)*2)*3)*4
如下图：
方法名： :+
描述： 在数组后面添加一个元素(添加的元素在后，就在数组 尾部 添加，冒号要离数组近)
返回值： 数组
示例：
val a = Array(1,2,3)
val b = a :+ 1
如下图：
方法名： :\
描述： 对数组中所有的元素从右向左遍历，进行相同的迭代操作，foldRight 的简写(冒号要离数组近)
返回值： 计算结果
示例：
val a = List(1, 2, 3, 4)
val b = (a :\ 10) (_ - _) // 1-(2-(3-(4-10)))
val c = (a :\ 10) (_ * _) // 1*(2*(3*(4*10)))
如下图：
方法名： addString
描述： 将数组中的元素逐个添加到StringBuilder中
返回值： StringBuilder
示例：
val a = List(1, 2, 3, 4)
val b = new StringBuilder()
a.addString(b)
如下图：
方法名： aggregate
描述：
返回值：
示例：
如下图：
方法名： andThen
描述： 表示方法的连续调用，相当于嵌套函数 g(f(x)) （需满足第一个函数的返回值类型是第二个函数的输入值类型）
返回值： 外层函数的返回值类型
示例：
val pf1:PartialFunction[Int,String] = { //定义一个偏函数，输入 1 返回 "one"
case i if i == 1 => "One"
}
val pf2:PartialFunction[String,String] = { //定义一个偏函数，输入"one" 返回 "This num is 1"
case str if str eq "One" => "This num is 1"
}
val num = pf1 andThen pf2
num(1)
如下图：
方法名： apply
描述： 按下标取数组数据
返回值： 数组中的元素类型
示例：
val a = Array(1,2,3,4)
a.apply(2) //等同于直接写a(2)
a(2)
如下图：
方法名： applyOrElse
描述： 接收2个参数，第一个是调用的参数，第二个是个回调函数。如果第一个调用的参数匹配，返回匹配的值，否则调用回调函数。（回调函数的输入类型需与调用参数类型一致）
返回值：
示例：
val pf1:PartialFunction[Int,String] = { //定义一个偏函数，输入 1 返回 "one"
case i if i == 1 => "One"
}
pf1.applyOrElse(1,{num:Int=>"two"}) //输入1匹配到"one"
pf1.applyOrElse(2,{num:Int=>"two"}) //输入2匹配失败则触发回调函数，返回 "Two" 字符串
pf1.applyOrElse(3,{num:Int=>"two"}) //输入3匹配失败则触发回调函数，返回 "Two" 字符串
如下图：
方法名： array
描述： scala中数组是用来存储同类型的元素结构，数组中本身size不可变，但是数组中元素可变，可重新赋值
返回值：
示例：
//声明一个String类型的数组
var arr:Array[String] = new Array[String](3) //长度为3，未赋值：null null null
var arr = new Array[String](3) //长度为3，未赋值：null null null
var arr1 = Array("java","scala","python") //长度为3，赋值："java","scala","python"
//添加、修改元素
arr(0) = "java"
arr(1) = "scala"
arr(2) = "python"
//索引
arr(0)
arr(1)
arr(2)
//遍历打印
arr.foreach(println)
如下图：
方法名： canEqual
描述： 判断两个对象是否可以进行比较(基本上都可以比较)
返回值： boolean
示例：
val a = Array(1,2,3)
val b = List(4,5,6)
val c = "hello"
val d = 5
a.canEqual(b)
a.canEqual(c)
a.canEqual(d)
如下图：
方法名： clone
描述： 创建一个数组的副本，复制数组的值,但不会引用地址
返回值： 数组
示例：
val a = Array(1,2,3,4)
val b = a.clone()
如下图：
方法名： collect
描述： 通过执行一个并行计算（偏函数），得到一个新的数组对象
返回值：
示例： 通过下面的偏函数，把数组中的小写的 a 转换为大写的 A
val fun: PartialFunction[Char, Char] = {
case 'a' => 'A'
case x => x
}
val a = Array('a', 'b', 'c')
val b = a.collect(fun)
println(b.mkString(",")) // A,b,c
如下图：
方法名： collectFirst
描述： 在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
返回值：
示例： 定义一个偏函数，当被执行对象为 Int 类型时，进行乘 100 的操作
val fun: PartialFunction[Any, Int] = {
case x: Int => x * 100
}
val a = Array(1, 'a', "b")
val b = arr.collectFirst(fun)
println(b) // Some(100)
如下图：
方法名： combinations
描述： combinations 表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于 “abc”、“cba”，视为相同组合，参数 n 表示序列长度，就是几个字符为一组
返回值：
示例：
val a = Array("a", "b", "c")
val b = arr.combinations(2)
b.foreach(x => println(x.mkString(",")))
/**
* a,b
* a,c
* b,c
*/
如下图：
方法名： companion
描述：
返回值：
示例：
如下图：
方法名： compose
描述：
返回值：
示例：
如下图：
方法名： contains
描述： 判断序列中是否包含指定对象
返回值：
示例：
val a = List(1, 2, 3, 4)
println(a.contains(1)) // true
如下图：
方法名： containsSlice
描述： 判断当前序列中是否包含另一个序列
返回值：
示例：
val a = List(1, 2, 3, 4)
val b = List(2, 3)
println(a.containsSlice(b)) // true
如下图：
方法名： copyToArray
描述： 将当前数组元素复制到另一个数组中(还可以指定起始下标引入)
返回值：
示例：
val a = Array(1, 2, 3)
val b: Array[Int] = new Array(5)
a.copyToArray(b)
println(b.mkString(",")) // 1,2,3,0,0
a.copyToArray(b, 1, 2)
println(b.mkString(",")) // 0,1,2,0,0
如下图：
方法名： copyToBuffer
描述： 将数组中的元素复制到 Buffer 中
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b: ArrayBuffer[Int] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(",")) // 1,2,3,4
如下图：
方法名： corresponds
描述： 判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(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)(_ < _)) // true
如下图：
方法名： count
描述： 统计符合条件的元素个数
返回值：
示例： 下面代码统计数组中大于 2 的元素个数
val a = Array(1, 2, 3, 4)
println(a.count(x => x > 2)) // 2
如下图：
方法名： deep
描述：
返回值：
示例：
如下图：
方法名： diff
描述： 计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.diff(b)
println(c.mkString(",")) // 1,2
如下图：
方法名： distinct
描述： 去除当前集合中重复的元素，只保留一个
返回值：
示例：
val a = Array(1, 2, 2, 3, 4, 4)
val b = a.distinct
println(b.mkString(",")) // 1,2,3,4
如下图：
方法名： drop
描述： 将当前数组中前 n 个元素去除，返回一个新数组
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.drop(2)
println(b.mkString(",")) // 3,4
如下图：
方法名： dropRight
描述： 功能同 drop，去掉尾部的 n 个元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.dropRight(2)
println(b.mkString(",")) // 1,2
如下图：
方法名： dropWhile
描述： 去除当前数组中符合条件的元素，返回剩余的数组，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组
返回值：
示例： 下面去除数组 a 中大于 2 的元素，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 (2,3,4)
val a = Array(1, 2, 3, 4)
val b = a.dropWhile(x => x < 2)
println(b.mkString(",")) // 2,3,4
val b = a.dropWhile(x => x > 2)
println(b.mkString(",")) // 1,2,3,4
如下图：
方法名： elemManifest
描述：
返回值：
示例：
如下图：
方法名： elemTag
描述：
返回值：
示例：
如下图：
方法名： endsWith
描述： 判断当前序列是否以某个序列结尾
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = Array(3, 4)
println(a.endsWith(b)) // true
如下图：
方法名： exists
描述： 判断当前数组是否包含符合条件的元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.exists(x => x == 3)) // true
println(a.exists(x => x == 30)) // false
如下图：
方法名： filter
描述： 取得当前数组中符合条件的元素，组成新的数组返回
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.filter(x => x > 2)
println(b.mkString(",")) // 3,4
如下图：
方法名： filterNot
描述：
返回值：
示例：
如下图：
方法名： find
描述： 查找第一个符合条件的元素，返回 Option
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.find(x => x > 2)
println(b) // Some(3)
如下图：
方法名： flatMap
描述： 对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是 GenTraversableOnce 及其子类
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.flatMap(x => 1 to x)
println(b.mkString(","))
/**
* 1,1,2,1,2,3,1,2,3,4
* 从 1 开始，分别对集合 a 中的每个元素生成一个递增序列，过程如下
* 1
* 1,2
* 1,2,3
* 1,2,3,4
*/
如下图：
方法名： flatten
描述：
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.flatMap(x => 1 to x)
println(b.mkString(","))
/**
* 1,1,2,1,2,3,1,2,3,4
* 从 1 开始，分别对集合 a 中的每个元素生成一个递增序列，过程如下
* 1
* 1,2
* 1,2,3
* 1,2,3,4
*/
如下图：
方法名： fold
描述： 对序列中的每个元素进行二元运算，和 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
*/
}
如下图：
方法名： foldLeft
描述： 从左到右计算，简写方式：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
*/
}
如下图：
方法名： foldRight
描述： 从右到左计算，简写方式：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
*/
}
如下图：
方法名： forall
描述： 检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.forall(x => x > 0)) // true
println(a.forall(x => x > 2)) // false
如下图：
方法名： foreach
描述： 遍历序列中的元素，进行 f 操作
返回值：
示例：
val a = Array(1, 2, 3, 4)
a.foreach(x => println(x * 10))
/**
* 10
* 20
* 30
* 40
*/
如下图：
方法名： genericBuilder
描述：
返回值：
示例：
如下图：
方法名： groupBy
描述： 按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
返回值：
示例： 把数组中小于 3 的元素分到一组，其他元素的分到另一组，返回 Map[String, Array[Int]]
val a = Array(1, 2, 3, 4)
val b = a.groupBy(x => x match {
case x if (x < 3) => "small"
case _ => "big"
})
b.foreach(x => println(x._1 + ": " + x._2.mkString(",")))
/**
* small: 1,2
* big: 3,4
*/
如下图：
方法名： grouped
描述： 按指定数量分组，每组有 size 个元素，返回一个迭代器
返回值：
示例：
val a = Array(1, 2, 3, 4, 5)
val b = a.grouped(3).toList
b.foreach(x => println("第 " + (b.indexOf(x) + 1) + " 组: " + x.mkString(",")))
/**
* 第 1 组: 1,2,3
* 第 2 组: 4,5
*/
如下图：
方法名： hasDefiniteSize
描述： 检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.hasDefiniteSize) // true
如下图：
方法名： head
描述： 返回序列的第一个元素，如果序列为空，将引发错误
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.head) // 1
如下图：
方法名： headOption
描述： 返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.headOption) // Some(1)
如下图：
方法名： indexOf
描述： 返回元素 elem 在序列中第一次出现的索引，指定从索引 from 开始查找
返回值：
示例：
val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3)) // 1
val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3, 2)) // 3
如下图：
方法名： indexOfSlice
描述： 检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引(指定从索引 from 开始查找，并返回第一次出现该序列的索引)
返回值：
示例：
val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.indexOfSlice(b)) // 1
如下图：
方法名： indexWhere
描述： 返回当前序列中第一个满足条件 p 的元素的索引,指定从索引 from 开始查找
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.indexWhere(x => x > 2)) // 2
val a = Array(1, 2, 3, 4)
println(a.indexWhere(x => x > 2, 3)) // 3
如下图：
方法名： indices
描述： 返回当前序列索引集合
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.indices
println(b.mkString(",")) // 0,1,2,3
如下图：
方法名： init
描述： 返回当前序列中不包含最后一个元素的序列
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.init
println(b.mkString(",")) // 1,2,3
如下图：
方法名： inits
描述： 对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.inits.toList
for (i <- 0 until b.length) {
val s = "第 %d 个值: %s"
println(s.format(i + 1, b(i).mkString(",")))
}
/**
* 第 1 个值: 1,2,3,4
* 第 2 个值: 1,2,3
* 第 3 个值: 1,2
* 第 4 个值: 1
* 第 5 个值:
*/
如下图：
方法名： intersect
描述： 取两个集合的交集
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.intersect(b)
println(c.mkString(",")) // 3,4
如下图：
方法名： isDefinedAt
描述： 判断序列中是否存在指定索引
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.isDefinedAt(1)) // true
println(a.isDefinedAt(10)) // false
如下图：
方法名： isEmpty
描述： 判断序列是否为空
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = new Array[Int](0)
println(a.isEmpty) // false
println(b.isEmpty) // true
如下图：
方法名： isTraversableAgain
描述： 判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.iterator
println(a.isTraversableAgain) // true
println(b.isTraversableAgain) // false
如下图：
方法名： iterator
描述： 生成当前序列的迭代器
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.iterator
println(b.mkString(",")) // 1,2,3,4
如下图：
方法名： last
描述： 返回序列的最后一个元素，如果序列为空，将引发错误
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.last) // 4
如下图：
方法名： lastIndexOf
描述： 返回元素 elem 在序列中最后一次出现的索引 (返回元素 elem 在序列中最后一次出现的索引，指定在索引 end 之前（包括）的元素中查找)
返回值：
示例：
val a = Array(1, 3, 2, 3, 4)
println(a.lastIndexOf(3)) // 3
val a = Array(1, 3, 2, 3, 4)
println(a.lastIndexOf(3, 2)) // 1
如下图：
方法名： lastIndexOfSlice
描述： 检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引 (检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引，指定在索引 end 之前（包括）的元素中查找)
返回值：
示例：
val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.lastIndexOfSlice(b)) // 3
val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.lastIndexOfSlice(b, 2)) // 1
如下图：
方法名： lastIndexWhere
描述： 返回当前序列中最后一个满足条件 p 的元素的索引 (返回当前序列中最后一个满足条件 p 的元素的索引，指定在索引 end 之前（包括）的元素中查找)
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.lastIndexWhere(Int => x > 2)) // 3
val a = Array(1, 2, 3, 4)
println(a.lastIndexWhere(x => x > 2, 2)) // 2
如下图：
方法名： lastOption
描述： 返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.lastOption) // Some(4)
如下图：
方法名： length
描述： 返回序列元素个数
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.length) // 4
如下图：
方法名： lengthCompare
描述： 比较序列的长度和参数 len，返回序列的长度 - len
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.lengthCompare(3)) // 1
println(a.lengthCompare(4)) // 0
println(a.lengthCompare(5)) // -1
如下图：
方法名： lift
描述：
返回值：
示例：
如下图：
方法名： map
描述： 对序列中的元素进行 f 操作，返回生成的新序列
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.map(x => x * 10)
println(b.mkString(",")) // 10,20,30,40
如下图：
方法名： max
描述： 返回序列中最大的元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.max) // 4
如下图：
方法名： maxBy
描述： 返回序列中符合条件的第一个元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.maxBy(x => x > 2)) // 3
如下图：
方法名： min
描述： 返回序列中最小的元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.min) // 1
如下图：
方法名： minBy
描述： 返回序列中不符合条件的第一个元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.minBy(x => x < 2)) // 2
如下图：
方法名： mkString
描述： 将序列中所有元素拼接成一个字符串 (mkString(start, sep, end)将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾)
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.mkString) // 1234
val a = Array(1, 2, 3, 4)
println(a.mkString("(", ",", ")")) // (1,2,3,4)
如下图：
方法名： nonEmpty
描述： 判断序列是否不为空
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = new Array[Int](0)
println(a.nonEmpty) // true
println(b.nonEmpty) // false
如下图：
方法名： orElse
描述：
返回值：
示例：
如下图：
方法名： padTo
描述： 填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列
返回值：
示例： 填充一个长度为 7 的序列，不足位补 8
val a = Array(1, 2, 3, 4)
val b = a.padTo(7, 8)
println(b.mkString(",")) // 1,2,3,4,8,8,8
如下图：
方法名： par
描述： 返回一个并行实现，产生的并行序列不能被修改
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.par
println(b.mkString(",")) // 1,2,3,4
如下图：
方法名： partition
描述： 按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
返回值：
示例： 下面以序列元素是否是偶数来拆分
val a = Array(1, 2, 3, 4)
val b: (Array[Int], Array[Int]) = a.partition(x => x % 2 == 0)
println("偶数: " + b._1.mkString(",")) // 偶数: 2,4
println("奇数: " + b._2.mkString(",")) // 奇数: 1,3
如下图：
方法名： patch
描述： 批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that
返回值：
示例： 从 a 的第二个元素开始，取两个元素，即 2 和 3 ，将这两个元素替换为序列 b
val a = Array(1, 2, 3, 4)
val b = Array(7, 8, 9)
val c = a.patch(1, b, 2)
println(c.mkString(",")) // 1,7,8,9,4
如下图：
方法名： permutations
描述： permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合
返回值：
示例：
val a = Array("a", "b", "c")
val b = a.permutations.toList
b.foreach( x => println(x.mkString(",")))
/**
* a,b,c
* a,c,b
* b,a,c
* b,c,a
* c,a,b
* c,b,a
*/
如下图：
方法名： prefixLength
描述： 给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.prefixLength(x => x < 3)) // 2
如下图：
方法名： product
描述： 返回所有元素乘积的值
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.product) // 1*2*3*4=24
如下图：
方法名： reduce
描述： 同 fold，不需要初始值
返回值：
示例：
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.reduce(seqno)
println("b = " + b)
/**
* seq_exp = 1 + 2
* seq_exp = 3 + 3
* seq_exp = 6 + 4
* b = 10
*/
}
如下图：
方法名： reduceLeft
描述： 同 foldLeft，从左向右计算，不需要初始值
返回值：
示例：
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.reduceLeft(seqno)
println("b = " + b)
/**
* seq_exp = 1 + 2
* seq_exp = 3 + 3
* seq_exp = 6 + 4
* b = 10
*/
}
如下图：
方法名： reduceLeftOption
描述： 同 reduceLeft，返回 Option
返回值：
示例：
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.reduceLeftOption(seqno)
println("b = " + b)
/**
* seq_exp = 1 + 2
* seq_exp = 3 + 3
* seq_exp = 6 + 4
* b = Some(10)
*/
}
如下图：
方法名： reduceOption
描述：
返回值：
示例：
如下图：
方法名： reduceRight
描述： 同 foldRight，从右向左计算，不需要初始值
返回值：
示例：
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.reduceRight(seqno)
println("b = " + b)
/**
* seq_exp = 3 + 4
* seq_exp = 2 + 7
* seq_exp = 1 + 9
* b = 10
*/
}
如下图：
方法名： reduceRightOption
描述： 同 reduceRight，返回 Option
返回值：
示例：
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.reduceRightOption(seqno)
println("b = " + b)
/**
* seq_exp = 3 + 4
* seq_exp = 2 + 7
* seq_exp = 1 + 9
* b = Some(10)
*/
}
如下图：
方法名： take
描述：
返回值：
示例：
如下图：
方法名： reverse
描述： 反转序列
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.reverse
println(b.mkString(",")) // 4,3,2,1
如下图：
方法名： reverseIterator
描述： 生成反向迭代器
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.reverseIterator
b.foreach(x => print(x + " ")) // 4 3 2 1
如下图：
方法名： reverseMap
描述： 同 map，方向相反
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.reverseMap(x => x * 10)
println(b.mkString(",")) // 40,30,20,10
如下图：
方法名： runWith
描述：
返回值：
示例：
如下图：
方法名： sameElements
描述： 判断两个序列是否顺序和对应位置上的元素都一样
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = Array(1, 2, 3, 4)
println(a.sameElements(b)) // true
val c = Array(1, 3, 2, 4)
println(a.sameElements(c)) // false
如下图：
方法名： scan
描述： 同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.scan(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15
如下图：
方法名： scanLeft
描述： 同 foldLeft，从左向右计算，每一步的计算结果放到一个新的集合中返回
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.scanLeft(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15
如下图：
方法名： scanRight
描述： 同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.scanRight(5)(_ + _)
println(b.mkString(",")) // 15,14,12,9,5
如下图：
方法名： segmentLength
描述： 从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个
返回值：
示例：
val a = Array(1, 2, 3, 1, 1, 1, 4)
println(a.segmentLength(x => x < 3, 3)) // 3
如下图：
方法名： seq
描述： 产生一个引用当前序列的 sequential 视图
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.seq
println(b.mkString(",")) // 1,2,3,4
如下图：
方法名： size
描述： 返回序列元素个数，同 length
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.size) // 4
如下图：
方法名： slice
描述： 返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.slice(1, 3)
println(b.mkString(",")) // 2,3
如下图：
方法名： sliding
描述： 滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束 (sliding(size, step) 从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束。该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始)
返回值：
示例：
val a = Array(1, 2, 3, 4, 5)
val b = a.sliding(3).toList
for (i <- 0 to b.length - 1) {
val s = "第 %d 组: %s"
println(s.format(i + 1, b(i).mkString(",")))
}
/**
* 第 1 组: 1,2,3
* 第 2 组: 2,3,4
* 第 3 组: 3,4,5
*/
val a = Array(1, 2, 3, 4, 5)
val b = a.sliding(3, 2).toList
for (i <- 0 to b.length - 1) {
val s = "第 %d 组: %s"
println(s.format(i + 1, b(i).mkString(",")))
}
/**
* 第 1 组: 1,2,3
* 第 2 组: 3,4,5
*/
如下图：
方法名： sortBy
描述： 按指定的排序规则对序列排序
返回值：
示例：
val a = Array(3, 2, 1, 4)
val b = a.sortBy(x => x) // 按 x 从小到大，即对原序列升序排列
println("升序: " + b.mkString(",")) // 1,2,3,4
val c = a.sortBy(x => 0 - x) // 按 -x 从小到大，即对原序列降序排列
println("降序: " + c.mkString(",")) // 4,3,2,1
如下图：
方法名： sortWith
描述：
返回值：
示例：
如下图：
方法名： sorted
描述： 使用默认的排序规则对序列排序
返回值：
示例：
val a = Array(3, 2, 1, 4)
val b = a.sorted // 默认升序排列
println(b.mkString(",")) // 1,2,3,4
如下图：
方法名： span
描述： 将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.span(x => x < 3)
println(b._1.mkString(",")) // 1,2
println(b._2.mkString(",")) // 3,4
如下图：
方法名： splitAt
描述： 从指定位置开始，把序列拆分成两个数组
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.splitAt(2)
println(b._1.mkString(",")) // 1,2
println(b._2.mkString(",")) // 3,4
如下图：
方法名： startsWith
描述： 判断序列是否以某个序列开始 (startsWith(that, offset) 判断序列从指定偏移处是否以某个序列开始)
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = Array(1, 2)
println(a.startsWith(b)) // true
val a = Array(1, 2, 3, 4)
val b = Array(2, 3)
println(a.startsWith(b, 1)) // true
如下图：
方法名： stringPrefix
描述： 返回 toString 结果的前缀
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.toString()) // [I@3ab39c39
println(a.stringPrefix) // [I
如下图：
方法名： sum
描述： 序列求和，元素需为 Numeric[T] 类型
返回值：
示例：
val a = Array(1, 2, 3, 4)
println(a.sum) // 10
如下图：
方法名： tail
描述： 返回当前序列中不包含第一个元素的序列
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.tail
println(b.mkString(",")) // 2,3,4
如下图：
方法名： tails
描述： 同 inits，每一步都进行 tail 操作
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.tails.toList
for (i <- 0 until b.length) {
val s = "第 %d 个值: %s"
println(s.format(i + 1, b(i).mkString(",")))
}
/**
* 第 1 个值: 1,2,3,4
* 第 2 个值: 2,3,4
* 第 3 个值: 3,4
* 第 4 个值: 4
* 第 5 个值:
*/
如下图：
方法名： take
描述： 返回当前序列中，前 n 个元素组成的序列
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.take(3)
println(b.mkString(",")) // 1,2,3
如下图：
方法名： takeRight
描述： 返回当前序列中，从右边开始，后 n 个元素组成的序列
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.takeRight(3)
println(b.mkString(",")) // 2,3,4
如下图：
方法名： takeWhile
描述： 返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.takeWhile(x => x < 3)
print(b.mkString(",")) // 1,2
如下图：
方法名： to
描述：
返回值：
示例：
如下图：
方法名： toArray
描述： 将序列转换成 Array 类型
返回值：
示例：
如下图：
方法名： toBuffer
描述： 将序列转换成 Buffer 类型
返回值：
示例：
如下图：
方法名： toIndexedSeq
描述： 将序列转换成 IndexedSeq 类型
返回值：
示例：
如下图：
方法名： toIterable
描述： 将序列转换成可迭代的类型
返回值：
示例：
如下图：
方法名： toIterator
描述： 将序列转换成迭代器，同 iterator 方法
返回值：
示例：
如下图：
方法名： toList
描述： 将序列转换成 List 类型
返回值：
示例：
如下图：
方法名： toMap
描述： 将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型
返回值：
示例：
如下图：
方法名： toSeq
描述： 将序列转换成 Seq 类型
返回值：
示例：
如下图：
方法名： toSet
描述： 将序列转换成 Set 类型
返回值：
示例：
如下图：
方法名： toStream
描述： 将序列转换成 Stream 类型
返回值：
示例：
如下图：
方法名： toTraversable
描述：
返回值：
示例：
如下图：
方法名： toVector
描述： 将序列转换成 Vector 类型
返回值：
示例：
如下图：
方法名： transform
描述：
返回值：
示例：
如下图：
方法名： transpose
描述： 矩阵转置，二维数组行列转换
返回值：
示例：
val a = Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
val b = a.transpose
b.foreach(x => println((x.mkString(","))))
/**
* a,c,e
* b,d,f
*/
如下图：
方法名： union
描述： 合并两个序列，同操作符 ++
返回值：
示例：
val a = Array(1, 2)
val b = Array(3, 4)
val c = a.union(b)
println(c.mkString(",")) // 1,2,3,4
如下图：
方法名： unzip
描述： 将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组
返回值：
示例：
val chars = Array(("a", "b"), ("c", "d"))
val b = chars.unzip
println(b._1.mkString(",")) // a,c
println(b._2.mkString(",")) // b,d
如下图：
方法名： unzip3
描述： 将含有三个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组
返回值：
示例：
val chars = Array(("a", "b", "x"), ("c", "d", "y"), ("e", "f", "z"))
val b = chars.unzip3
println(b._1.mkString(",")) // a,c,e
println(b._2.mkString(",")) // b,d,f
println(b._3.mkString(",")) // x,y,z
如下图：
方法名： update
描述： 将序列中 i 索引处的元素更新为 x
返回值：
示例：
val a = Array(1, 2, 3, 4)
a.update(1, 7)
println(a.mkString(",")) //1,7,3,4
如下图：
方法名： updated
描述： 将序列中 i 索引处的元素更新为 x，并返回替换后的数组
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.updated(1, 7)
println(b.mkString(",")) //1,7,3,4
如下图：
方法名： view
描述： 返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.view(1, 3)
println(b.mkString(",")) // 2,3
如下图：
方法名： withFilter
描述： 根据条件 p 过滤元素
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = a.withFilter(x => x > 2).map(x => x)
println(b.mkString(",")) // 3,4
如下图：
方法名： zip
描述： 将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同
返回值：
示例：
val a = Array(1, 2, 3, 4)
val b = Array(4, 3, 2, 1)
val c = a.zip(b)
println(c.mkString(",")) // (1,4),(2,3),(3,2),(4,1)
如下图：
方法名： zipAll
描述： 同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem
返回值：
示例：
val a = Array(1, 2, 3, 4, 5, 6, 7)
val b = Array(5, 4, 3, 2, 1)
val c = a.zipAll(b, 8, 9) // (1,5),(2,4),(3,3),(4,2),(5,1),(6,9),(7,9)
println(c.mkString(","))
val x = Array(1, 2, 3, 4)
val y = Array(6, 5, 4, 3, 2, 1)
val z = x.zipAll(y, 8, 9) // (1,6),(2,5),(3,4),(4,3),(8,2),(8,1)
println(z.mkString(","))
如下图：
方法名： zipWithIndex
描述： 序列中的每个元素和它的索引组成一个元组数组
返回值：
示例：
val a = Array('a', 'b', 'c', 'd')
val b = a.zipWithIndex
println(b.mkString(",")) // (a,0),(b,1),(c,2),(d,3)
如下图：