scala函数大全
目录
++函数,合并两个集合并且返回一个新数组,++:返回类型和:后的集合类型一样
++:函数,操纵数的类型决定返回结果的类型
+:函数,:于数组前放入元素
/:函数,执行最后一个括号内的加减乘除操作以二叉树的形式
:\\函数,执行最后一个括号内的加减乘除操作以二叉树的形式
addString函数添加元素
aggregate函数：聚合分析,先使用给定参数和集合内容进行函数1操作,再将结果进行函数2操作
aggregate函数：聚合分析,先使用给定参数和集合内容进行函数1操作(按照奇数偶数进行分组操作),再将结果进行函数2操作
apply函数：取出索引处的元素
canEqual函数,比较两边，为any的子类都是true
charAt函数,获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。
collectFirst函数：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
定义偏函数
combinations函数：排列组合,所有不重复的组合,结果为迭代器集,迭代器只能读一次,之后会释放内存
containsSlice函数：判断数组中是否有指定序列(包括顺序)/必须一摸一样
contains函数：判断序列中是否包含指定对象
copyToArray函数：数组导入数组/集合
copyToBuffer函数：将数组中的内容拷贝到Buffer中
corresponds函数:判断arr数组是否满足arr1条件匹配
count函数：计算符合条件的个数
diff函数：差集，计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回
distinct函数：去除当前集合中重复的元素，只保留一个
drop函数：删除元素
dropRight函数：功能同 drop，去掉尾部的 n 个元素
dropWhile函数:去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组
endsWith函数：判断是否以某个序列结尾
exists函数：判断当前数组是否包含符合条件的元素
filter函数:过滤,取得当前数组中符合条件的元素，组成新的数组返回
filterNot函数:过滤,取得当前数组中不符合条件的元素，组成新的数组返回
find函数：寻找第一个符合条件的元素
flatMap函数：对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类
flatten函数：将二维数组的所有元素联合在一起，形成一个一维数组返回
fold函数:对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的执行过程。
foldLeft函数:从左到右计算
foldRight函数:从右到左计算
forall函数:检测序列中的元素是否都满足条件 p，如果序列为空，返回true
foreach函数：检测序列中的元素是否都满足条件 p，如果序列为空，返回true
groupBy函数:按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列
grouped函数：按指定数量分组，每组有 size 数量个元素，返回一个集合
hasDefiniteSize函数：检测序列是否存在有限的长度，对应Stream这样的流数据，返回false
head函数：返回序列的第一个元素，如果序列为空，将引发错误
headOption函数:返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None
indexOf函数:返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回
indexOfSlice函数:检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引
indexWhere函数:返回当前序列中第一个满足 p 条件的元素的索引
indices函数：返回当前序列索引集合
init函数：返回当前序列中不包含最后一个元素的序列,4个元素就返回前三个元素
inits函数：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象
intersect函数：取两个集合的交集,即两个集合都有的元素
isDefinedAt函数：判断序列中是否存在指定索引
isEmpty函数：判断当前序列是否为空
isTraversableAgain函数：判断序列是否可以反复遍历
iterator函数：对序列中的每个元素产生一个 iterator,迭代遍历
last函数：取得序列中最后一个元素
lastIndexOf函数：取得序列中最后一个等于elem元素的位置
lastIndexOfSlice函数：判断当前序列是否含有其他定义好的序列，并且返回最后一次出现该序列位置的索引
lastOption函数:返回当前序列中最后一个对象
length函数：返回当前序列中元素的个数
map函数：对序列中的元素进行定义好的计算操作
max函数：返回序列中最大的元素
minBy函数：返回序列中第一个符合条件的最大的元素
mkString函数：将所有元素组合成一个字符串
nonEmpty函数：判断序列不为空
padTo函数：后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列
par函数：返回一个并行实现，产生的并行序列为val，不可被修改
partition函数：按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分
patch函数;批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that
permutations函数：排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样
prefixLength函数：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
product函数：返回所有元素乘积的值
reduce函数：同 fold，对序列中的每个元素进行二元运算，不需要初始值
reduceLeft函数：从左向右计算
reduceRight函数：从右向左计算
reduceLeftOption函数：计算Option，参考reduceLeft
reduceRightOption函数：计算Option，参考reduceRight
reverse函数：反转序列
reverseIterator函数：反向生成迭代
reverseMap函数：同 map 方向相反
sameElements函数：判断两个序列是否顺序和对应位置上的元素都一样
scan函数：用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值
scanLeft函数：从左向右计算
scanRight函数：从右向左计算
segmentLength函数：从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度
seq函数：产生一个引用当前序列的 sequential 视图
size函数：序列元素个数，同 length
slice函数：取出当前序列中，from 到 until 之间的片段
sliding函数：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
sliding函数：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止 \\n该方法，可以设置步进 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始
sortBy函数：按指定的排序规则排序
sortWith函数：自定义排序方法
sorted函数：使用默认的排序规则对序列排序
span函数：分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合
splitAt函数：从指定位置开始，把序列拆分成两个集合
startsWith函数:从指定偏移处，是否以某个序列开始
startsWith函数：是否以某个序列开始
stringPrefix函数：返回 toString 结果的前缀
subSequence函数：返回 start 和 end 间的字符序列
sum函数：序列求和，元素需为Numeric[T]类型
tail函数：返回除了当前序列第一个元素的其它元素组成的序列
take函数：返回当前序列中前 n 个元素组成的序列
takeRight函数：返回当前序列中，从右边开始，选择 n 个元素组成的序列
takeWhile函数：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
toArray函数：转换成 Array 类型
toBuffer函数：转换成 Buffer 类型
toIndexedSeq函数：转换成 IndexedSeq 类型
toIterable函数：转换成可迭代的类型
toIterator函数：转换成可迭代的类型
toList函数：转换为List类型
toMap函数：同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据
toSeq函数：
toSet函数：
toStream函数：
toVector函数：
transpose函数：矩阵转换，二维数组行列转换
union函数：联合两个序列，同操作符 ++
unzip函数：将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列
unzip3函数：将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列
update函数：将序列中 i 索引处的元素更新为 x
updated函数：将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
view函数：返回 from 到 until 间的序列，不包括 until 处的元素
withFilter函数：根据条件 p 过滤元素
zip函数：将两个序列对应位置上的元素组成一个pair序列
zipAll函数：同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem
zipWithIndex函数：序列中的每个元素和它的索引组成一个序列
++函数,合并两个集合并且返回一个新数组,++:返回类型和:后的集合类型一样
println("++函数,合并两个集合并且返回一个新数组,++:返回类型和:后的集合类型一样")var numbers = Array(1, 2, 3, 4)var numbers2 = Array(3, 4, 5, 6)println((numbers ++ numbers2).mkString)
++:函数,操纵数的类型决定返回结果的类型
println("++:函数,操纵数的类型决定返回结果的类型")val a1 = List(1, 2)val b1 = scala.collection.mutable.LinkedList(3, 4)val c1 = a1 ++: b1println(c1.getClass().getName())
+:函数,:于数组前放入元素
println("+:函数,:于数组前放入元素")println((numbers +: numbers2).mkString)
/:函数,执行最后一个括号内的加减乘除操作以二叉树的形式
println("/:函数,执行最后一个括号内的加减乘除操作以二叉树的形式")val c2 = (10 /: numbers) (_ + _) //10为初始值，从左边来加println(c2)
:\\函数,执行最后一个括号内的加减乘除操作以二叉树的形式
println(":\\\\函数,执行最后一个括号内的加减乘除操作以二叉树的形式")val c3 = (numbers :\\ 10) (_ + _) //10为初始值从右边来加println(c3)var c4 = (numbers :\\ 11) ((x, y) => {println(x, y);x - y})println(c4)
addString函数添加元素
println("addString函数添加元素")numbers.addString(new StringBuilder())numbers.addString(new StringBuilder(), "$")numbers.addString(new StringBuilder(), "^")numbers.addString(new StringBuilder(), "(", "^", ")")aggregate函数：聚合分析,先使用给定参数和集合内容进行函数1操作,再将结果进行函数2操作
println("aggregate函数：聚合分析,先使用给定参数和集合内容进行函数1操作,再将结果进行函数2操作")println(arr.par.aggregate(5)(_ + _, _ + _)) //多线程,结果可能不准确,为16或21,慎用
aggregate函数：聚合分析,先使用给定参数和集合内容进行函数1操作(按照奇数偶数进行分组操作),再将结果进行函数2操作
println("aggregate函数：聚合分析,先使用给定参数和集合内容进行函数1操作(按照奇数偶数进行分组操作),再将结果进行函数2操作")arr.aggregate(0)((x, y) => {println("left", x, y);x + y}, (x, y) => {println("right", x, y);x + y})
apply函数：取出索引处的元素
println("apply函数：取出索引处的元素")val first = numbers(0)println(first)
canEqual函数,比较两边，为any的子类都是true
println("canEqual函数,比较两边，为any的子类都是true")var bool = arr.canEqual(1) //判断能不能比较两边,只要是any的子类就是true(没什么用)charAt函数,获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。
println("charAt函数,获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。")var array1 = Array('a', 'b', 'c')val c = array1.charAt(1) == array1(1)var arr2 = arr :+ 124def abc(sz: Array[Int]) = {sz(1) = 100;}collectFirst函数：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
println(" collectFirst函数：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算")arr.collect(pfun)arr.collectFirst(pfun).get //结果是Some类型的,some可以get到值(1个)arr.collect { case x if (x % 2 == 0) => x + 5 }arr.combinations(2)println("collect调用偏函数,通过执行一个并行计算（偏函数），得到一个新的数组对象")var char = Array('a', 'b', 'c')char.collect({ case 'a' => 'A' case x => x })println(char.mkString(","))println("将数组中所有的值通过偏函数计算得到一个新的数组对象")var info = Array("male", "男", "1", "female", "女", "0")val strings = info.collect({ case "男" => "male" case "女" => "female" case "1" => "male" case "0" => "female" })println(strings.mkString(","))
定义偏函数
//注意地址值,注意对象的值前后变化//定义偏函数def pfun: PartialFunction[Int, Int] = {case x if (x % 2 == 0) => x + 5}combinations函数：排列组合,所有不重复的组合,结果为迭代器集,迭代器只能读一次,之后会释放内存
//排列组合,所有不重复的组合,结果为迭代器集,迭代器只能读一次,之后会释放内存println("combinations函数：排列组合,所有不重复的组合,结果为迭代器集,迭代器只能读一次,之后会释放内存")arr.combinations(2).foreach(x => println(x.mkString(",")))arr.contains(2)containsSlice函数：判断数组中是否有指定序列(包括顺序)/必须一摸一样
//判断数组中是否有指定序列(包括顺序)/必须一摸一样println(" containsSlice函数：判断数组中是否有指定序列(包括顺序)/必须一摸一样")arr.containsSlice(List(1, 2))contains函数：判断序列中是否包含指定对象
println("contains函数：判断序列中是否包含指定对象")println(arr.contains(1))
copyToArray函数：数组导入数组/集合
//数组导入数组/集合println("copyToArray函数：数组导入数组/集合")var arr3 = Array(0, 0, 0, 0, 0)arr.copyToArray(arr3, 1, 3)arr3.foreach(print)copyToBuffer函数：将数组中的内容拷贝到Buffer中
println("copyToBuffer函数：将数组中的内容拷贝到Buffer中")import scala.collection.mutable.ArrayBuffer //导包var lst = ArrayBuffer[Int]() //指定泛型arr.copyToBuffer(lst);lst.foreach(println) //遍历输出corresponds函数:判断arr数组是否满足arr1条件匹配
//判断是否满足条件匹配println("corresponds函数:判断arr数组是否满足arr1条件匹配")var arr1 = Array(1, 2, 3)arr.corresponds(arr1)(_ <= _)arr.corresponds(arr1)(_ >= _) //判断满足条件(同长度)(arr :+ 10).copyToArray(arr1)arr.copyToArray(arr1 :+ 10)count函数：计算符合条件的个数
//计算符合条件的个数println("count函数：计算符合条件的个数")arr.count(x => x % 2 == 0)var ints = Array(5, 3, 8, 7, 9, 10, 3)println(ints.count(_ > 8))
diff函数：差集，计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回
//差集println("diff函数：差集，计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回")val a = Array(1, 2, 3, 4)val b = Array(4, 5, 6, 7)a.diff(b).foreach(println)
distinct函数：去除当前集合中重复的元素，只保留一个
println("distinct函数：去除当前集合中重复的元素，只保留一个")val a2 = Array(1, 2, 3, 4, 4, 5, 5, 6, 6)val c5 = a2.distinctprintln(c5.mkString(","))
drop函数：删除元素
println("drop函数：删除元素")arr.drop(1)dropRight函数：功能同 drop，去掉尾部的 n 个元素
println("dropRight函数：功能同 drop，去掉尾部的 n 个元素")arr.dropRight(1)dropWhile函数:去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组
println("dropWhile函数:去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组")val a3 = Array(3, 2, 3, 4)val c6 = a3.dropWhile({ x: Int => x > 2 })println(c6.mkString(","))
endsWith函数：判断是否以某个序列结尾
println("endsWith函数：判断是否以某个序列结尾")val b2 = Array(3, 4)println(a3.endsWith(b2))
exists函数：判断当前数组是否包含符合条件的元素
println("exists函数：判断当前数组是否包含符合条件的元素")println(a3.exists({ x: Int => x == 3 }))println(a3.exists({ x: Int => x == 30 }))
filter函数:过滤,取得当前数组中符合条件的元素，组成新的数组返回
println("filter函数:过滤,取得当前数组中符合条件的元素，组成新的数组返回")println(arr.filter(x => x % 1 == 0).mkString(","))
filterNot函数:过滤,取得当前数组中不符合条件的元素，组成新的数组返回
println("filterNot函数:过滤,取得当前数组中不符合条件的元素，组成新的数组返回")println(arr.filterNot(x => x % 2 == 0).mkString(","))
find函数：寻找第一个符合条件的元素
println("find函数：寻找第一个符合条件的元素")println(arr.mkString(","))println(arr.find(_ > 1))arr.find({ x: Int => x > 1 })
flatMap函数：对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类
println("flatMap函数：对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类")val b3 = a.flatMap(x => 1 to x)println(b3.mkString(","))
flatten函数：将二维数组的所有元素联合在一起，形成一个一维数组返回
println(" flatten函数：将二维数组的所有元素联合在一起，形成一个一维数组返回")val dArr = Array(Array(1, 2, 3), Array(4, 5, 6))val c7 = dArr.flattenprintln(c7.mkString(","))
fold函数:对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的执行过程。
println("fold函数:对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的执行过程。 ")def seqno(m: Int, n: Int): Int = {val s = "seq_exp=%d+%d"println(s.format(m, n))return m + n}def combine(m: Int, n: Int): Int = {val s = "com_exp=%d+%d"println(s.format(m, n))return m + n}val b4 = a.fold(5)(seqno)println(b4)val c8 = a.par.aggregate(5)(seqno, combine)println(c8)
foldLeft函数:从左到右计算
println("foldLeft函数:从左到右计算")val b5 = a.foldLeft(5)(seqno)
foldRight函数:从右到左计算
println("foldRight函数:从右到左计算")val b6 = a.foldRight(5)(seqno)
forall函数:检测序列中的元素是否都满足条件 p，如果序列为空，返回true
println("forall函数:检测序列中的元素是否都满足条件 p，如果序列为空，返回true")val b7 = a.forall({ x: Int => x > 0 })println(b7)val b8 = a.forall({ x: Int => x > 2 })println(b8) 
foreach函数：检测序列中的元素是否都满足条件 p，如果序列为空，返回true
println("foreach函数：检测序列中的元素是否都满足条件 p，如果序列为空，返回true")val b9 = a.foreach(x => println(x * 100))
groupBy函数:按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列
println("groupBy函数:按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列")val b10 = a.groupBy(x => x match {case x if (x < 3) => "small"case _ => "big"})println(b10)
grouped函数：按指定数量分组，每组有 size 数量个元素，返回一个集合
println("grouped函数：按指定数量分组，每组有 size 数量个元素，返回一个集合")val b11 = a.grouped(3).toListb11.foreach((x) => println("第" + (b.indexOf(x) + 1) + "组:" + x.mkString(",")))
hasDefiniteSize函数：检测序列是否存在有限的长度，对应Stream这样的流数据，返回false
println("hasDefiniteSize函数：检测序列是否存在有限的长度，对应Stream这样的流数据，返回false")println(a.hasDefiniteSize)
head函数：返回序列的第一个元素，如果序列为空，将引发错误
println("head函数：返回序列的第一个元素，如果序列为空，将引发错误")println(a.head)
headOption函数:返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None
println("headOption函数:返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None")println(a.headOption)
indexOf函数:返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回
println("indexOf函数:返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回")println(a.indexOf(3))indexOfSlice函数:检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引
println("indexOfSlice函数:检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引")val b12 = Array(2, 3)println(a.indexOfSlice(b11))println(a.indexOfSlice(b11, 3))
indexWhere函数:返回当前序列中第一个满足 p 条件的元素的索引
println("indexWhere函数:返回当前序列中第一个满足 p 条件的元素的索引")println(a.indexWhere({ x: Int => x > 3 }))println(a.indexWhere({ x: Int => x > 3 }, 4))
indices函数：返回当前序列索引集合
println(" indices函数：返回当前序列索引集合")val b13 = a.indicesprintln(b13.mkString(","))
init函数：返回当前序列中不包含最后一个元素的序列,4个元素就返回前三个元素
println("init函数：返回当前序列中不包含最后一个元素的序列,4个元素就返回前三个元素")val b15 = a.initprintln(b.mkString(","))
inits函数：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象
println("inits函数：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象")val b14 = a.inits.toListfor (i <- 1 to b14.length) {val s = "第%d个值：%s"println(s.format(i, b14(i - 1).mkString(",")))}
intersect函数：取两个集合的交集,即两个集合都有的元素
println("intersect函数：取两个集合的交集,即两个集合都有的元素")// val a = Array(1, 2, 3, 4)// val b = Array(4, 5, 6, 7)val c9 = a.intersect(b)println(c9.mkString(","))
isDefinedAt函数：判断序列中是否存在指定索引
println("isDefinedAt函数：判断序列中是否存在指定索引")// val a = Array(1, 2, 3, 4)println(a.isDefinedAt(1))println(a.isDefinedAt(11))
isEmpty函数：判断当前序列是否为空
println(" isEmpty函数：判断当前序列是否为空")println(a.isEmpty)
isTraversableAgain函数：判断序列是否可以反复遍历
println(" isTraversableAgain函数：判断序列是否可以反复遍历")val b16 = a.iteratorval b17 = a.toTraversableprintln(b16.isTraversableAgain)println(b17.isTraversableAgain)
iterator函数：对序列中的每个元素产生一个 iterator,迭代遍历
println("iterator函数：对序列中的每个元素产生一个 iterator,迭代遍历")println(a.iterator.mkString(","))
last函数：取得序列中最后一个元素
println("last函数：取得序列中最后一个元素")println(a.last)
lastIndexOf函数：取得序列中最后一个等于elem元素的位置
println("lastIndexOf函数：取得序列中最后一个等于elem元素的位置")val a4 = Array(1, 2, 2, 3, 4, 5, 6, 8, 2, 5)println(a4.lastIndexOf(5))println("可以指定结束end的位置")println(a4.lastIndexOf(2, 5))
lastIndexOfSlice函数：判断当前序列是否含有其他定义好的序列，并且返回最后一次出现该序列位置的索引
println("lastIndexOfSlice函数：判断当前序列是否含有其他定义好的序列，并且返回最后一次出现该序列位置的索引")val b18 = Array(2, 3)println(a4.lastIndexOfSlice(b18))println("也可以指定结束end的位置")println(a4.lastIndexOfSlice(b18, 5))
lastOption函数:返回当前序列中最后一个对象
println("lastOption函数:返回当前序列中最后一个对象")println(a.lastOption)
length函数：返回当前序列中元素的个数
println("length函数：返回当前序列中元素的个数")println(a.length)
map函数：对序列中的元素进行定义好的计算操作
println("map函数：对序列中的元素进行定义好的计算操作")val b19 = a.map({ x: Int => x * 10 })println(b19.mkString(","))val a5 = Array("name", "age", "gender")val b20 = a5.map({ x: String => x + "no" })println(b20.mkString(","))
max函数：返回序列中最大的元素
println("max函数：返回序列中最大的元素")println(a.max)
minBy函数：返回序列中第一个符合条件的最大的元素
println("minBy函数：返回序列中第一个符合条件的最大的元素")println(a.minBy({ x: Int => x > 1 }))
mkString函数：将所有元素组合成一个字符串
println("mkString函数：将所有元素组合成一个字符串")println(a.mkString)println("将所有元素组合成一个字符串，以 sep 作为元素间的分隔符")println(a.mkString(","))println("将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾")println(a.mkString("{", ",", "}"))
nonEmpty函数：判断序列不为空
println(" nonEmpty函数：判断序列不为空")println(a.nonEmpty)
padTo函数：后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列
println("padTo函数：后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列")val b21 = a.padTo(10, 81)println(b21.mkString(","))
par函数：返回一个并行实现，产生的并行序列为val，不可被修改
println("par函数：返回一个并行实现，产生的并行序列为val，不可被修改")val b22 = a.parprintln(b22.mkString(","))
partition函数：按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分
println(" partition函数：按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分")val b23: (Array[Int], Array[Int]) = a.partition({ x: Int => x % 2 == 0 })println(b23._1.mkString(","))println(b23._2.mkString(","))
patch函数;批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that
println("patch函数;批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that")val b24 = Array(3, 4, 6)val c10 = a.patch(1, b24, 2) //从第2个元素开始取两个元素，将其替换为b24序列里面的元素println(c10.mkString(","))
permutations函数：排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样
println(" permutations函数：排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样")val b25 = a.permutations.toListprintln(b25.mkString(","))val b26 = a.combinations(5).toListprintln(b26.mkString(","))
prefixLength函数：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
println("prefixLength函数：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p")val b27 = a.prefixLength({ x: Int => x < 4 })println(b27)
product函数：返回所有元素乘积的值
println("product函数：返回所有元素乘积的值")val b28 = a.productprintln(b28)
reduce函数：同 fold，对序列中的每个元素进行二元运算，不需要初始值
println("reduce函数：同 fold，对序列中的每个元素进行二元运算，不需要初始值")// def seqno(m:Int,n:Int): Int ={// val s ="seq_exp=%d+%d"// println(s.format(m,n))// return m+n// }// def combine(m:Int,n:Int): Int ={// val s ="com_exp=%d+%d"// println(s.format(m,n))// return m+n// }val b29 = a.fold(5)(seqno)println(b29)val c11 = a.reduce(seqno)println(c11)
reduceLeft函数：从左向右计算
println("reduceLeft函数：从左向右计算")val c12 = a.reduceLeft(seqno)println(c12)
reduceRight函数：从右向左计算
println("reduceRight函数：从右向左计算")val c13 = a.reduceRight(seqno)println(c13)
reduceLeftOption函数：计算Option，参考reduceLeft
println("reduceLeftOption函数：计算Option，参考reduceLeft")val c14 = a.reduceLeftOption(seqno)println(c14)
reduceRightOption函数：计算Option，参考reduceRight
println("reduceRightOption函数：计算Option，参考reduceRight")val c15 = a.reduceRightOption(seqno)println(c15)
reverse函数：反转序列
println("reverse函数：反转序列")val b30 = a.reverseprintln(b30.mkString(","))
reverseIterator函数：反向生成迭代
println("reverseIterator函数：反向生成迭代")val b31 = a.reverseIteratorprintln(b31.mkString(","))
reverseMap函数：同 map 方向相反
println("reverseMap函数：同 map 方向相反")val b32 = a.reverseMap({ x: Int => x * 10 })println(b32.mkString(","))
sameElements函数：判断两个序列是否顺序和对应位置上的元素都一样
println("sameElements函数：判断两个序列是否顺序和对应位置上的元素都一样")println(a.sameElements(b))val c16 = Array(1, 2, 3, 4)println(c16.sameElements(a))
scan函数：用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值
println("scan函数：用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值")val b33 = a.scan(5)(seqno)println(b33.mkString(","))
scanLeft函数：从左向右计算
println("scanLeft函数：从左向右计算")val b34 = a.scanLeft(5)(seqno)println(b34.mkString(","))
scanRight函数：从右向左计算
println("scanRight函数：从右向左计算")val b35 = a.scanRight(5)(seqno)println(b35.mkString(","))
segmentLength函数：从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度
println("segmentLength函数：从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度")val a8 = Array(1, 2, 3, 1, 1, 1, 1, 1, 1, 4, 5)val b36 = a8.segmentLength({ x: Int => x < 3 }, 3)println(b36)
seq函数：产生一个引用当前序列的 sequential 视图
size函数：序列元素个数，同 length
println("size函数：序列元素个数，同 length")println(a.size)
slice函数：取出当前序列中，from 到 until 之间的片段
println("slice函数：取出当前序列中，from 到 until 之间的片段")val b37 = a.slice(1, 3)println(b37.mkString(","))
sliding函数：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
println("sliding函数：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止")val b38 = a.sliding(3).toListfor (i <- 0 to b38.length - 1) {val s = "第%d个：%s"println(s.format(i, b38(i).mkString(",")))}println(b38.mkString(",")) 
sliding函数：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止 \\n该方法，可以设置步进 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始
println("sliding函数：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止 \\n该方法，可以设置步进 step，第一个元素组合完后，下一个从 上一个元素位置+step后的位置处的元素开始")val b39 = a.sliding(3, 2).toListfor (i <- 0 to b39.length - 1) {val s = "第%d个：%s"println(s.format(i, b39(i).mkString(",")))}println(b39.mkString(","))
sortBy函数：按指定的排序规则排序
println("sortBy函数：按指定的排序规则排序")val b40 = a.sortBy({ x: Int => x })println(b40.mkString(","))
sortWith函数：自定义排序方法
println("sortWith函数：自定义排序方法")val b41 = a.sortWith(_.compareTo(_) > 0)println(b41.mkString(","))
sorted函数：使用默认的排序规则对序列排序
println("sorted函数：使用默认的排序规则对序列排序")println(a.sorted.mkString(","))
span函数：分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合
println("span函数：分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合")val b42 = a.span({ x: Int => x > 2 })println(b42._1.mkString(","))println(b42._2.mkString(","))
splitAt函数：从指定位置开始，把序列拆分成两个集合
println("splitAt函数：从指定位置开始，把序列拆分成两个集合")val b43 = a.splitAt(2)println(b43._1.mkString(","))println(b43._2.mkString(","))
startsWith函数:从指定偏移处，是否以某个序列开始
println("startsWith函数:从指定偏移处，是否以某个序列开始")val b44 = Array(2, 3)println(a.startsWith(b44, 0))startsWith函数：是否以某个序列开始
println("startsWith函数：是否以某个序列开始")val b45 = Array(2, 3)println(a.startsWith(b45))
stringPrefix函数：返回 toString 结果的前缀
println("stringPrefix函数：返回 toString 结果的前缀")println(a.toString())println(a.stringPrefix)
subSequence函数：返回 start 和 end 间的字符序列
println("subSequence函数：返回 start 和 end 间的字符序列")val chars1 = Array('a', 'b', 'c', 'd')val b46 = chars1.subSequence(1, 3)println(b46.toString)
sum函数：序列求和，元素需为Numeric[T]类型
println("sum函数：序列求和，元素需为Numeric[T]类型")println(a.sum)
tail函数：返回除了当前序列第一个元素的其它元素组成的序列
println("tail函数：返回除了当前序列第一个元素的其它元素组成的序列")println(a.tail.mkString(","))
take函数：返回当前序列中前 n 个元素组成的序列
println("take函数：返回当前序列中前 n 个元素组成的序列")println(a.take(3))
takeRight函数：返回当前序列中，从右边开始，选择 n 个元素组成的序列
println("takeRight函数：返回当前序列中，从右边开始，选择 n 个元素组成的序列")println(a.takeRight(3).mkString(","))
takeWhile函数：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
println("takeWhile函数：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列")println(a.takeWhile({ x: Int => x < 3 }).mkString(","))
toArray函数：转换成 Array 类型
println(" toArray函数：转换成 Array 类型")val d = ArrayBuffer(1, 2, 3, 4)println(d.toArray.getClass.getName)
toBuffer函数：转换成 Buffer 类型
toIndexedSeq函数：转换成 IndexedSeq 类型
toIterable函数：转换成可迭代的类型
toIterator函数：转换成可迭代的类型
toList函数：转换为List类型
toMap函数：同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据
toSeq函数：
toSet函数：
toStream函数：
toVector函数：
transpose函数：矩阵转换，二维数组行列转换
println("f transpose函数：矩阵转换，二维数组行列转换")val chars2 = Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))val b48 = chars2.transposeprintln(b48.mkString(","))
union函数：联合两个序列，同操作符 ++
println("union函数：联合两个序列，同操作符 ++")val a12 = Array(1, 2, 3, 4, 5)val b49 = Array(6, 7)val c17 = a12.union(b49)println(c17.mkString(","))
unzip函数：将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列
println("unzip函数：将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列")val a13 = Array(("a", "b"), ("c", "d"))val b50 = a13.unzipprintln(b50._1.mkString(","))println(b50._2.mkString(","))
unzip3函数：将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列
println("unzip3函数：将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列")val a14 = Array(("a", "b", "c"), ("d", "e", "f"), ("g", "h", "y"))val b51 = a13.unzipprintln(b51._1.mkString(","))println(b51._2.mkString(","))update函数：将序列中 i 索引处的元素更新为 x
println("update函数：将序列中 i 索引处的元素更新为 x")a.update(1, 9)println(a.mkString(","))
updated函数：将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
println("updated函数：将序列中 i 索引处的元素更新为 x ,并返回替换后的数组")println(a.updated(1, 9).mkString(","))
view函数：返回 from 到 until 间的序列，不包括 until 处的元素
println(" view函数：返回 from 到 until 间的序列，不包括 until 处的元素")println(a.view(1, 3).mkString(","))
withFilter函数：根据条件 p 过滤元素
println("withFilter函数：根据条件 p 过滤元素")println(a.withFilter({ x: Int => x > 3 }).map(x => x).mkString(","))
zip函数：将两个序列对应位置上的元素组成一个pair序列
println("zip函数：将两个序列对应位置上的元素组成一个pair序列")val c20 = a.zip(b)println(c20.mkString(","))
zipAll函数：同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem
println("zipAll函数：同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem")val c21 = a.zipAll(b, 9, 8)println(c21.mkString(","))
zipWithIndex函数：序列中的每个元素和它的索引组成一个序列
println("zipWithIndex函数：序列中的每个元素和它的索引组成一个序列")println(a.zipWithIndex.mkString(","))