scala常用函数大全

一、添加、更新元素函数

++ 两个集合相加，返回一个左边集合类型的新集合

    val a = Array(1, 2)
    val b = Array(3, 4)
    val c = a ++ b
    println(c.mkString(",")) // 1,2,3,4

++：两个集合相加，返回一个右边集合类型的新集合

val a = List(1, 2)
val b = scala.collection.mutable.LinkedList(3, 4)
val c = a ++: b
println(c.getClass().getName()) // c 的类型: scala.collection.mutable.LinkedList

+：与 :+ 是指往集合中添加元素
：号所在边为集合
➕号所在边为元素
返回一个新的集合

    val a = List(1, 2)
    val b = 0 +: a
    println(b.mkString(",")) // 0,1,2

  val a = List(1, 2)
    val b = a :+ 3
    println(b.mkString(",")) // 1,2,3

/: 是foldleft的简写，对数组中的元素从左向右遍历
:\ 是foldright的简写 ，对数组中的元素从右向左遍历
以上两个都是对集合中的元素每个元素做相同的迭代操作
返回一个新的序列

    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
    println("b: " + b) // b: 20
    println("c: " + c) // c: 240

 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)))
    println("b: " + b) // b: -8
    println("c: " + c) // c: 240

addString(b) 将数组中的元素逐个添加到StringBuilder中
addString(b,seq) seq是分割符 以怎么样的形式添加到StringBuilder中
a.stringPrefix 返回toString结果的前缀
a.union(b) 合并两个序列 同++
a.update(i,x) 将序列中 i 索引处的元素更新为 x 不返回的新的数组
a.updated(i,x) 将序列中 i 索引处的元素更新为 x 并返回替换后的数组

二、关于索引的函数

a.charAt(index) 获取index索引处的字符 只能用于字符序列
a.apply（n） 获取序列某个索引处的值a.apply(1)=a(1) 返回一个序列值

a.head 返回序列的第一个元素
a.last 返回序列的最后一个元素
a.headOption 返回序列的第一个元素的Option对象
a.lastOption 返回序列的最后一个元素的Option对象

a.reverse 反转序列
a.reverseIterator 生成反向迭代器
a.reverseMap 同map 方向相反

a.indexOf(elem) 返回元素在序列中第一次出现的索引
a.indexOf(elem,from) 指定索引从from处开始查找
a.indexOfSlice(that) 检测当前序列是否包含序列that 并返回第一次出现该序列的索引（
第一个元素的索引）
a.indexOfSlice(that,from)
a.indexWhere(匿名函数) 返回当前序列第一个满足条件的索引
a.indexWhere(匿名函数 from)

a.indices 返回当前序列索引集合
a.zipWithIndex 序列中的每个元素和她的索引组成的一个元祖数组

a.lastIndexOf(elem) 返回元素elem在序列最后一次出现的索引
a.lastIndexOf(elem,end)
a.lastIndexOfSlice(that)
a.lastIndexOfSlice(that,end)
a.lastIndexWhere§ 返回当前序列最后一个满足条件的索引
a.lastIndexWhere(p,end)

三、类型转换函数

a.toArray （下面用户都一样，可以互相转换）
toBuffer
toIndexSeq
toIterable
toIterator
toList
toMap
toSeq
toSet
toStream
toVector

四、聚合函数

最大值 最小值
a.max
a.maxBy（条件） 返回序列中符合条件的最大元素
a.min
a.minBy（条件） 返回序列中符合条件的最小元素
a.sum 求和
a.count(匿名函数) 统计符合条件的元素个数 返回一个值
a.product 返回所有元素乘积的值
a.aggregate(初始值)(seqno,combine) 聚合计算 参数时两个方法 当不分区时 只执行seqno 函数体是自己的业务逻辑 a.aggregate(2）(seqno,combine)
分区时 执行seqno,combine两个函数 seqno中分区计算的结果 在使用combine
进行合并计算 a.par.aggregate(2)(seqno,combine) 返回一个聚合结果
a.fold()(seqno) 和aggregate功能类似 只是执行过程不同
a.par.fold()()
a.foldLeft()()
a.foldRight()()
a.reduce(seqno)
a.reduceLeft()
a.reduceLeftOption()
a.reduceRight()
a.reduceRightOption()
a.scan()(+) 同fold 把每一的计算结果放到一个新的集合中返回 fold返回最后结果
a.scanLeft()()
a.scanRight()()
以上函数都是一个序列函数的聚合

五、排序、分组函数

a.sortBy(x=>x) 升序排序
a.sortBy(x=>x*(-1)) 降序排列
a.sorted 默认排列 升序排序

a.groupBy(匿名函数) 根据条件进行分组 条件由匿名函数匹配 返回值是Map类型 每个key对应
一个数组
匿名函数中可以使用match 进行模式匹配 来自由分组
a.grouped(3) 按数量分组 返回一个迭代器（可以使用toList转换下） 每组n个元素

六、序列基础函数

a.diff(b) 计算a与b的差集 即b中没有a中有的额元素 返回一个新的集合
a.intersect(b) 两个集合的交集 返回一个新的序列
a.distinct 去除a中的重复元素 返回一个新的数组
a.drop(n)：去除前n个元素 返回一个新的数组
a.dropRight(n) 去除后n的元素 返回一个新的数组
a.dropWhile(匿名函数) 去除符合条件的元素（第一元就要满足条件）返回剩余
的数组 第一个元素不满足条件时 返回整个数组
a.clone() 创建一个序列的副本 返回新的序列
a.copyToArray(b) 将元素复制到另一个数组中 返回一个新的序列
a.copyToArray(b ,start) start 是指开始从新数组的哪个位置复制
a.copyToArray(b,start,len) len 是指复制原数组的长度
都返回一个新的数组b
a.copyToBuffer(b) 将元素复制到buffer b中 返回b
a.combinations(n) 对数组中的元素进行不重复的n个元素一起的排列组合 返回一个新的序列
a.permutations（n） permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合
返回一个序列迭代器

a.flatMap(匿名函数) 对当前序列中的每个元素进行操作 返回一个新的序列、
a.flatten 扁平化 列转行 将所有二维数组元素组合在一起，形成一个一维数组返回
a.foreach(匿名函数) 遍历a中的元素 进行f操作 脱外衣 没有返回值
a.map(匿名函数) 遍历a中的元素 进行f操作 返回一个原类型的新的序列

a.mkString 将元素所有元素拼接成一个字符串
a.mkString(seq)
a.mkString(start: String, sep: String, end: String)

七、判断函数

a.endWith(b) 判断a序列是否以b序列结尾 返回true或者false
a.startWith(that) 判断序列是否以某个系列开始
a.startWith(that，offset)
a.corresponds(b)(条件) 判断a b 两个序列的长度是否相等 同时对应位置的某个
元素是否都符合某个条件 符合返回true 否则返回false
a.sameElements(b) 判断两个序列是否顺和对应位置上的元素都一样 返回 true false

a.contains(对象) 判断序列中是否包含指定对象 返回true 或者 false
a.containsSlice(序列) 判断一个序列中是否包含另一个序列 返回true或者false
a.exists(匿名函数) 判断a数组是否包含符合条件的元素 返回true false
a.forall(匿名函数) 检查a中的元素是否都满足条件 返回true或者false

a.canEqual(b) 比较两个对象是否可以比较 返回true或者false
a.hasDefiniteSize 检测序列是否存在有限长度 是返回true 否则返回false
a.isDefinedAt(索引) 判断序列中是否存在指定索引 true false
a.isEmpty 判断序列是否为空 true false、
a.nonEmpty 判断序列是否不为空
a.isTraverableAgain 判断序列是否可以反复遍历

八、where条件函数

a.collect(偏函数) 根据偏函数的逻辑 得到一个新的数组对象
a.collectFirst(偏函数) 在a中查找符合第一个偏函数定义的元素 返回一个值

a.filter(匿名函数) 取得当前数组中满足条件的元素 返回一个新的数组
a.withFilter(匿名函数) 根据条件 p 过滤元素 需要加.map()
a.find(匿名函数) 查找第一个符合条件的元素 返回option 如Some(3)

a.tail 返回当前序列中不包含第一个元素的序列
a.tails 同inits 们每一步都进行tail操作
a.init 返回当前序列不包含最后一个元素的序列
a.inits 对集合中的元素进行init迭代操作 返回的是一个迭代器 可以使用toList转换下
a.length 返回序列的元素个数
a.lengthCompare(n) 序列长度-n
a.segmentLength(匿名函数，from) 从序列的form开始向后查找，满足条件p放入连续元素的长度
a.size 返回元素个数，同length
a.slice(from,until) 返回当前序列从from到until之间的序列
a.view(a,b) 返回当前序列中从 a 到 b 之间的序列，不包括b处的元素
a.subSequence(a,b) 返回a，b 之间的序列 不包括b
a.sliding(n) 滑动 从第一个元素开始 每个滑块都是n个元素 每次往后滑动一个，
a.sliding(n,seq)
a.take(n) 返回当前序列中，前n个元素组成的序列
a.takeRight(n) 返回当前序列中，后n个元素组成的序列
a.takeWhile(匿名函数) 返回当前序列中，满足条件的连续元素组成的序列

a.span(匿名函数) 将序列分成两个数组 满足条件的放到第一个数组，其余的放到
其余的放到第二个数组 返回的是包含这两个数组的元祖
a.partition（条件） 按条件序列拆分成两个数组，满足条件的放到第一个数组，其余的放到
第二个数组中，返回的是包含这两个数组的元祖
a.splitAt(n) 从n位置开始，把序列拆成两个分组

九、其他函数

a.iterator 生成当前序列的迭代器
a.padTo(len,elem) 填充一个长度为 len 的序列，不足位补elem 返回一个新的序列

a.par 返回一个并行实现 产生的并行序列不能被修改
a.patch(from,that,replaced) 批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that
a.prefixLength(匿名函数) 返回满足条件的序列的长度
a.seq 产生一个引用当前序列的视图
a.transpose 矩阵转置 二维数组行列转换

a.unzip 将含有两个二元组的数组 ，元祖中的数据一一组队，
返回包含这两个数组的元祖
a.unzip3 将含有两个三元组的数组 ，元祖中的数据一一组队，
返回包含这三个数组的元祖
a.zip(b) 将两个序列对应位置上的元素组成一个元祖数组，要求两个序列长度相同
a.zipAll(b) 同 zip ，但是允许两个序列长度不同，不足的自动填充