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 ++: 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(","))

文章来源地址https://www.toymoban.com/news/detail-406208.html

到了这里，关于scala函数大全的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！