目录
++函数,合并两个集合并且返回一个新数组,++:返回类型和:后的集合类型一样
aggregate函数：聚合分析,先使用给定参数和集合内容进行函数1操作,再将结果进行函数2操作
aggregate函数：聚合分析,先使用给定参数和集合内容进行函数1操作(按照奇数偶数进行分组操作),再将结果进行函数2操作
charAt函数,获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。
collectFirst函数：在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
combinations函数：排列组合,所有不重复的组合,结果为迭代器集,迭代器只能读一次,之后会释放内存
containsSlice函数：判断数组中是否有指定序列(包括顺序)/必须一摸一样
copyToBuffer函数：将数组中的内容拷贝到Buffer中
corresponds函数:判断arr数组是否满足arr1条件匹配
diff函数：差集，计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回
dropRight函数：功能同 drop，去掉尾部的 n 个元素
dropWhile函数:去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组
filter函数:过滤,取得当前数组中符合条件的元素，组成新的数组返回
filterNot函数:过滤,取得当前数组中不符合条件的元素，组成新的数组返回
flatMap函数：对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类
flatten函数：将二维数组的所有元素联合在一起，形成一个一维数组返回
fold函数:对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的执行过程。
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 条件的元素的索引
init函数：返回当前序列中不包含最后一个元素的序列,4个元素就返回前三个元素
intersect函数：取两个集合的交集,即两个集合都有的元素
isTraversableAgain函数：判断序列是否可以反复遍历
iterator函数：对序列中的每个元素产生一个 iterator,迭代遍历
lastIndexOf函数：取得序列中最后一个等于elem元素的位置
lastIndexOfSlice函数：判断当前序列是否含有其他定义好的序列，并且返回最后一次出现该序列位置的索引
padTo函数：后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列
par函数：返回一个并行实现，产生的并行序列为val，不可被修改
partition函数：按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分
patch函数;批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that
permutations函数：排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样
prefixLength函数：给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p
reduce函数：同 fold，对序列中的每个元素进行二元运算，不需要初始值
reduceLeftOption函数：计算Option，参考reduceLeft
reduceRightOption函数：计算Option，参考reduceRight
sameElements函数：判断两个序列是否顺序和对应位置上的元素都一样
scan函数：用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值
segmentLength函数：从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度
seq函数：产生一个引用当前序列的 sequential 视图
slice函数：取出当前序列中，from 到 until 之间的片段
sliding函数：从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
span函数：分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合
stringPrefix函数：返回 toString 结果的前缀
subSequence函数：返回 start 和 end 间的字符序列
tail函数：返回除了当前序列第一个元素的其它元素组成的序列
takeRight函数：返回当前序列中，从右边开始，选择 n 个元素组成的序列
takeWhile函数：返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列
toIndexedSeq函数：转换成 IndexedSeq 类型
toMap函数：同 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据
unzip函数：将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列
unzip3函数：将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列
updated函数：将序列中 i 索引处的元素更新为 x ,并返回替换后的数组
view函数：返回 from 到 until 间的序列，不包括 until 处的元素
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 ++: b1
println(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 :+ 124
def 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.distinct
println(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.flatten
println(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).toList
b11.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.indices
println(b13.mkString(","))
init函数：返回当前序列中不包含最后一个元素的序列,4个元素就返回前三个元素
println("init函数：返回当前序列中不包含最后一个元素的序列,4个元素就返回前三个元素")
val b15 = a.init
println(b.mkString(","))
inits函数：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象
println("inits函数：对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象")
val b14 = a.inits.toList
for (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.iterator
val b17 = a.toTraversable
println(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.par
println(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.toList
println(b25.mkString(","))
val b26 = a.combinations(5).toList
println(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.product
println(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.reverse
println(b30.mkString(","))
reverseIterator函数：反向生成迭代
println("reverseIterator函数：反向生成迭代")
val b31 = a.reverseIterator
println(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).toList
for (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).toList
for (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.transpose
println(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.unzip
println(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.unzip
println(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(","))
856
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
